ci(#2484): satisfy pyright strict-mode and 100% coverage

Second CI round caught two more things the local run did not:

1. pyright on the CI runs in a stricter mode than the default, and
   flagged every new test:
     - `anyio_backend` parametrize fixture needs an explicit `str` type
     - `monkeypatch` needs `pytest.MonkeyPatch`
     - `*args, **kwargs` on the stub stream class need `Any`
     - `__aiter__` / `__anext__` need return types
   All annotated; pyright now reports 0 errors on both files.

2. The project's coverage floor is `fail_under = 100`. Extracting the
   trio branch into its own helper function left lines 184-187 (the
   body of `_anyio_task_group_background`) and the `else:` on line
   304 uncovered, because every existing test runs on asyncio.
   Added `test_stdio_client_supports_lifo_cleanup_on_trio` —
   parametrised with `anyio_backend=["trio"]`, it exercises the trio
   branch end-to-end with the LIFO cleanup pattern that is valid on
   trio. Removed the `# pragma: lax no cover` markers on the helper
   and the else branch since coverage is now genuine, not silenced.

15/16 stdio tests pass locally (15 real pass + 1 Unix-only SIGINT
skip). pyright: 0 errors. ruff: clean.

Author: sakenuGOD

tests/client/test_stdio.py

@@ -574,7 +574,7 @@ def sigterm_handler(signum, frame):
 
 @pytest.mark.anyio
 @pytest.mark.parametrize("anyio_backend", ["asyncio"])
-async def test_stdio_client_supports_fifo_cleanup_on_asyncio(anyio_backend):
+async def test_stdio_client_supports_fifo_cleanup_on_asyncio(anyio_backend: str):
     """Regression for https://github.com/modelcontextprotocol/python-sdk/issues/577.
 
     Prior to the fix, closing two ``stdio_client`` transports in the order
@@ -611,7 +611,7 @@ async def test_stdio_client_supports_fifo_cleanup_on_asyncio(anyio_backend):
 
 @pytest.mark.anyio
 @pytest.mark.parametrize("anyio_backend", ["asyncio"])
-async def test_stdio_client_supports_lifo_cleanup_on_asyncio(anyio_backend):
+async def test_stdio_client_supports_lifo_cleanup_on_asyncio(anyio_backend: str):
     """Sanity check for the fix above: the historical LIFO cleanup path
     must still work unchanged on asyncio.
     """
@@ -632,7 +632,7 @@ async def test_stdio_client_supports_lifo_cleanup_on_asyncio(anyio_backend):
 
 @pytest.mark.anyio
 @pytest.mark.parametrize("anyio_backend", ["asyncio"])
-async def test_stdio_client_shared_exit_stack_fifo_on_asyncio(anyio_backend):
+async def test_stdio_client_shared_exit_stack_fifo_on_asyncio(anyio_backend: str):
     """The same story, but through a single ``AsyncExitStack`` that the
     caller then closes once. ExitStack runs callbacks in LIFO order on
     its own, so this case already worked — the test pins that behavior
@@ -646,26 +646,48 @@ async def test_stdio_client_shared_exit_stack_fifo_on_asyncio(anyio_backend):
         await stack.enter_async_context(stdio_client(params))
 
 
+@pytest.mark.anyio
+@pytest.mark.parametrize("anyio_backend", ["trio"])
+async def test_stdio_client_supports_lifo_cleanup_on_trio(anyio_backend: str):
+    """Coverage for the structured-concurrency branch of ``stdio_client``.
+
+    On trio the historical anyio task-group is kept — the FIFO fix from
+    #577 is asyncio-only because trio forbids orphan tasks by design.
+    This test just exercises the trio code path end-to-end with LIFO
+    cleanup (which works the same way it always has) so the trio
+    branch is not dead code under coverage.
+    """
+    params = StdioServerParameters(command=sys.executable, args=["-c", _QUIET_STDIN_STUB])
+
+    async with AsyncExitStack() as stack:
+        await stack.enter_async_context(stdio_client(params))
+        await stack.enter_async_context(stdio_client(params))
+
+
 @pytest.mark.anyio
 @pytest.mark.parametrize("anyio_backend", ["asyncio"])
-async def test_stdio_client_reader_crash_propagates_on_asyncio(anyio_backend, monkeypatch):
+async def test_stdio_client_reader_crash_propagates_on_asyncio(
+    anyio_backend: str, monkeypatch: pytest.MonkeyPatch
+) -> None:
     """Guardrail for the asyncio branch of #577: moving the reader/writer
     out of an anyio task group must NOT silently swallow exceptions
     they raise. An anyio task group would have re-raised those through
     the async ``with`` block; the asyncio path has to reproduce that
     contract by collecting the task results in ``__aexit__`` and
     re-raising anything that isn't cancellation / closed-resource.
     """
+    from typing import Any
+
     from mcp.client import stdio as stdio_mod
 
     class _BoomTextStream:
-        def __init__(self, *args, **kwargs):
+        def __init__(self, *args: Any, **kwargs: Any) -> None:
             pass
 
-        def __aiter__(self):
+        def __aiter__(self) -> "_BoomTextStream":
             return self
 
-        async def __anext__(self):
+        async def __anext__(self) -> str:
             raise RuntimeError("deliberate reader crash for #577 regression test")
 
     monkeypatch.setattr(stdio_mod, "TextReceiveStream", _BoomTextStream)