Add Task.Delay as GC root in ConnectAsync WhenAny

The async chain from ConnectAsync through initializeTask/processingTask
can become GC-unreachable on .NET 10/Ubuntu when the server process exits
before responding. The CancelAfter timer roots the chain through
CancellationToken registrations, but this path appears unreliable.

Task.Delay creates a System.Threading.Timer that is directly rooted in
the runtime's timer queue, providing a simple GC root chain:
Timer Queue -> Timer -> Task.Delay -> WhenAny -> ConnectAsync.

This ensures ConnectAsync always resumes within the initialization
timeout, even if intermediate state machines are collected.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: ericstj

src/ModelContextProtocol.Core/Client/McpClientImpl.cs

@@ -555,15 +555,29 @@ public async Task ConnectAsync(CancellationToken cancellationToken = default)
                     McpJsonUtilities.JsonContext.Default.InitializeResult,
                     cancellationToken: initializationCts.Token).AsTask();
 
-                // Race the initialize request against the processing loop. If the server process
-                // exits before responding, processingTask completes first and we must ensure the
-                // pending request TCS is signaled. The lock-based sweep in ProcessMessagesCoreAsync
-                // handles most cases, but if ConcurrentDictionary's non-atomic iteration missed the
-                // TCS, this explicit re-sweep catches it.
-                if (await Task.WhenAny(initializeTask, processingTask).ConfigureAwait(false) == processingTask
-                    && !initializeTask.IsCompleted)
+                // Race the initialize request against the processing loop and an independently-
+                // rooted timeout. Task.Delay creates a System.Threading.Timer rooted in the
+                // runtime's timer queue, which provides a GC root for the WhenAny continuation
+                // chain (Timer Queue → Timer → Task.Delay → WhenAny → ConnectAsync). This
+                // ensures ConnectAsync always resumes even in edge cases where the
+                // initializeTask/processingTask chains become otherwise GC-unreachable.
+                Task delayTask = Task.Delay(_options.InitializationTimeout, cancellationToken);
+                Task completed = await Task.WhenAny(initializeTask, processingTask, delayTask).ConfigureAwait(false);
+
+                if (completed != initializeTask && !initializeTask.IsCompleted)
                 {
+                    // Either the server process exited (processingTask) or the timeout fired
+                    // (delayTask) before initialization completed. Re-sweep pending requests
+                    // to signal the TCS in case ProcessMessagesCoreAsync's sweep missed it.
                     _sessionHandler.FailPendingRequests();
+
+                    if (!initializeTask.IsCompleted)
+                    {
+                        // The initialize task's async chain may be unreachable (intermediate
+                        // state machines collected by GC). Throw timeout directly.
+                        LogClientInitializationTimeout(_endpointName);
+                        throw new TimeoutException("Initialization timed out");
+                    }
                 }
 
                 var initializeResponse = await initializeTask.ConfigureAwait(false);