fix(connection): detect half-open sockets via TCP_USER_TIMEOUT

Symptom: you run a command and nothing comes back — the connection is actually
dead (server gone / network dropped) but the client sits "Connected", showing the
local echo with no server response, until you force a reconnect.

Cause: SO_KEEPALIVE / TcpKeepAliveTime only probe an IDLE socket. The moment a
command (or the NOP heartbeat) is sent, that data is in flight; on a half-open
peer it is never acknowledged, so keepalive doesn't run and TCP instead
retransmits the unacked data for ~15 minutes (tcp_retries2) before failing. The
read loop stays blocked the whole time, so no auto-reconnect fires.

Fix: set TCP_USER_TIMEOUT (Linux/Android) to 20s, which bounds how long
unacknowledged in-flight data is retransmitted before the OS fails the socket.
A half-open connection now surfaces in ~20s → the read loop completes → the
existing monitor auto-reconnects (and re-authenticates). It only trips on
genuinely unacked bytes, so a slow-but-alive server (still ACKing at the TCP
layer) never false-fires. Best-effort + platform-guarded; keepalive remains the
fallback elsewhere.

Verified the raw option round-trips on Linux (set 20000 → read back 20000);
Core suite (198) passes.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01HHCRc5CJ6595iMzEgYYdQp

Author: HarryCordewener

src/SharpClient.Core/Connection/TelnetConnection.cs

@@ -175,6 +175,33 @@ private static void TrySetTcpKeepAlive(Socket socket)
         try { socket.SetSocketOption(SocketOptionLevel.Tcp, SocketOptionName.TcpKeepAliveRetryCount, 3); } catch { }
     }
 
+    // Milliseconds of unacknowledged, in-flight data before the OS fails the connection. Catches a
+    // half-open peer where a sent command/heartbeat is never acked (the "I sent a command and nothing
+    // came back" hang). Only trips on genuinely unacked bytes, so a slow-but-alive server never fires it.
+    private const int TcpUserTimeoutMs = 20_000;
+
+    private static void TrySetTcpUserTimeout(Socket socket)
+    {
+        // TCP_USER_TIMEOUT is a Linux/Android option (there is no cross-platform SocketOptionName for it).
+        if (!OperatingSystem.IsLinux() && !OperatingSystem.IsAndroid())
+        {
+            return;
+        }
+
+        try
+        {
+            const int ipprotoTcp = 6;    // IPPROTO_TCP
+            const int tcpUserTimeout = 18; // TCP_USER_TIMEOUT
+            Span<byte> value = stackalloc byte[sizeof(int)];
+            BitConverter.TryWriteBytes(value, TcpUserTimeoutMs); // native byte order, as the option expects
+            socket.SetRawSocketOption(ipprotoTcp, tcpUserTimeout, value);
+        }
+        catch
+        {
+            // Best-effort — keepalive still provides eventual detection.
+        }
+    }
+
     // Application-level heartbeat: spans the whole connect lifetime (including auto-reconnect gaps),
     // sending a telnet NOP while Connected. Started on connect, stopped on intentional disconnect.
     private void StartHeartbeat()
@@ -237,6 +264,11 @@ private async Task EstablishConnectionAsync(string host, int port, CancellationT
         // Tune the keepalive so a dead peer surfaces in ~1 minute instead of the OS default
         // (often ~2h idle) — important on mobile networks that change while moving.
         TrySetTcpKeepAlive(client.Client);
+        // Also bound retransmission of unacknowledged data. Keepalive only probes an IDLE socket;
+        // when a command (or the NOP heartbeat) is in flight but never acked — a half-open peer —
+        // TCP would otherwise retransmit for ~15 min before failing, so the client sits "connected"
+        // with no responses. This makes that surface in ~20s instead.
+        TrySetTcpUserTimeout(client.Client);
         await client.ConnectAsync(host, port, cancellationToken);
 
         var (interpreter, readTask) = await _factory.CreateBuilder()