Restore anyio.open_process as primary Windows process creation method

This restores the pre-#596 behavior where anyio.open_process is tried
first, falling back to subprocess.Popen only when necessary (e.g., when
using SelectorEventLoop on Windows).

The approach:
1. Try anyio.open_process with CREATE_NO_WINDOW flag
2. If NotImplementedError, fall back to subprocess.Popen wrapper
3. If other exception, retry anyio.open_process without flags

Also refactored to extract the fallback logic into a separate
_create_windows_fallback_process function for better code organization.

Author: felixweinberger

src/mcp/client/stdio/win32.py

@@ -9,6 +9,7 @@
 from typing import BinaryIO, TextIO, cast
 
 import anyio
+from anyio.abc import Process
 from anyio.streams.file import FileReadStream, FileWriteStream
 
 
@@ -127,13 +128,13 @@ async def create_windows_process(
     env: dict[str, str] | None = None,
     errlog: TextIO | None = sys.stderr,
     cwd: Path | str | None = None,
-) -> FallbackProcess:
+) -> Process | FallbackProcess:
     """
     Creates a subprocess in a Windows-compatible way.
 
-    On Windows, asyncio.create_subprocess_exec has incomplete support
-    (NotImplementedError when trying to open subprocesses).
-    Therefore, we fallback to subprocess.Popen and wrap it for async usage.
+    First attempts to use anyio.open_process. If that fails
+    (e.g., with SelectorEventLoop on Windows), falls back
+    to subprocess.Popen wrapped for async usage.
 
     Args:
         command (str): The executable to run
@@ -143,7 +144,39 @@ async def create_windows_process(
         cwd (Path | str | None): Working directory for the subprocess
 
     Returns:
-        FallbackProcess: Async-compatible subprocess with stdin and stdout streams
+        Process | FallbackProcess: Async-compatible subprocess with stdin and stdout streams
+    """
+    try:
+        # Try with Windows-specific flags to hide console window
+        process = await anyio.open_process(
+            [command, *args],
+            env=env,
+            # Ensure we don't create console windows for each process
+            creationflags=subprocess.CREATE_NO_WINDOW  # type: ignore
+            if hasattr(subprocess, "CREATE_NO_WINDOW")
+            else 0,
+            stderr=errlog,
+            cwd=cwd,
+        )
+        return process
+    except NotImplementedError:
+        # If anyio fails (e.g., with SelectorEventLoop), fall back to subprocess.Popen
+        return await _create_windows_fallback_process(command, args, env=env, errlog=errlog, cwd=cwd)
+    except Exception:
+        # Don't raise, let's try to create the process without creation flags
+        process = await anyio.open_process([command, *args], env=env, stderr=errlog, cwd=cwd)
+        return process
+
+
+async def _create_windows_fallback_process(
+    command: str,
+    args: list[str],
+    env: dict[str, str] | None = None,
+    errlog: TextIO | None = sys.stderr,
+    cwd: Path | str | None = None,
+) -> FallbackProcess:
+    """
+    Create a FallbackProcess for Windows using subprocess.Popen.
     """
     try:
         # Try launching with creationflags to avoid opening a new console window