sockets: per-TCP-connection listing via netcfg

netcfg/sockets/list now enumerates each active TCP socket with:
- State (Established, Listen, SynSent, etc.)
- Local endpoint (e.g., 127.0.0.1:8080)
- Remote endpoint (e.g., 192.168.1.5:51234) or '-' if not connected

Per-protocol counts still shown:
  sockets: N (tcp=N udp=N icmp=N raw=N)
  tcp: Established 127.0.0.1:22 -> 10.0.0.5:54321
  tcp: Listen 0.0.0.0:80 -> -
  tcp: SynSent 192.168.1.1:1025 -> 8.8.8.8:53
  ...

Mirrors Linux 'ss -t' output format.
Uses smoltcp Socket enum pattern matching (was previously blocked
because Socket didn't expose type-check methods).

netstack/src/scheme/netcfg/mod.rs

@@ -156,7 +156,35 @@ fn mk_root_node(
             "list" => {
                 ro [socket_set] || {
                     let set = socket_set.borrow();
-                    format!("sockets: {}\n", set.iter().count())
+                    let mut tcp = 0u32;
+                    let mut udp = 0u32;
+                    let mut icmp = 0u32;
+                    let mut raw = 0u32;
+                    let mut out = String::from("");
+                    for (_handle, socket) in set.iter() {
+                        match socket {
+                            smoltcp::socket::Socket::Tcp(_) => tcp += 1,
+                            smoltcp::socket::Socket::Udp(_) => udp += 1,
+                            smoltcp::socket::Socket::Icmp(_) => icmp += 1,
+                            smoltcp::socket::Socket::Raw(_) => raw += 1,
+                            _ => {}
+                        }
+                    }
+                    let total = tcp + udp + icmp + raw;
+                    out.push_str(&format!("sockets: {} (tcp={} udp={} icmp={} raw={})\n",
+                        total, tcp, udp, icmp, raw));
+                    for (_handle, socket) in set.iter() {
+                        if let smoltcp::socket::Socket::Tcp(tcp_sock) = socket {
+                            let local = tcp_sock.local_endpoint();
+                            let remote = tcp_sock.remote_endpoint();
+                            let state = tcp_sock.state();
+                            out.push_str(&format!("tcp: {:?} {} -> {}\n",
+                                state,
+                                local.map(|e| format!("{}", e)).unwrap_or_else(|| "-".to_string()),
+                                remote.map(|e| format!("{}", e)).unwrap_or_else(|| "-".to_string())));
+                        }
+                    }
+                    out
                 }
             }
         },