… background

reader/writer and close streams on crash

Self-review of the first commit caught a regression: the asyncio
branch spawned stdout_reader / stdin_writer via asyncio.create_task
and did `try: await task except BaseException: pass` during cleanup,
which silently swallowed any exception the reader or writer raised.
An anyio task group would have re-raised that through the `async
with` block — the asyncio path has to reproduce that contract to
keep the fix observably equivalent.

Two changes:

1. `add_done_callback(_on_background_task_done)` — if a background
   task crashes while the caller is still inside the `yield`, close
   the memory streams immediately so any in-flight user read wakes
   up with `ClosedResourceError` instead of hanging forever. Mirrors
   the scope-cancellation side effect of a task group. The callback
   logs the exception at debug so operators can trace crashes that
   we only surface on the way out.

2. On `__aexit__` we now collect task results and re-raise the first
   non-cancellation, non-closed-resource exception. CancelledError
   and anyio.ClosedResourceError are expected during the teardown we
   just forced in `_cleanup_process_and_streams`, so they are
   swallowed; anything else (a real crash) propagates.

New regression test:
`test_stdio_client_reader_crash_propagates_on_asyncio` — injects a
TextReceiveStream that raises on the first `__anext__`, asserts the
exception is visible at the async-with exit. Confirmed it FAILS on
the first-commit version ("Failed: DID NOT RAISE"), so it is real
regression coverage, not a tautology.

All 14 stdio tests pass (10 pre-existing + 4 new, 1 Unix-only skip).
Full `tests/client/` pass (203 passed, 1 pre-existing xfail).

…overage

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.

… branches

Second CI round got coverage up to 99.97% but the last uncovered
lines are defensive cleanup paths that normal teardown does not
exercise and that do not warrant a dedicated test each:

  - `_on_done` callback's "task cancelled" early-return (normal
    teardown exits the reader/writer cleanly through stream-close,
    not via explicit cancellation).
  - `task.cancel()` guard when the task is somehow still pending by
    the time we reach the finally block (same reason — tasks should
    be done already).
  - CancelledError and ClosedResourceError catches in the result
    collection loop (symmetric with the case above; those arise
    only if the task was still active when we began teardown).

Each line is marked with a terse ``# pragma: no cover`` pointing at
the reason, matching the pattern already used elsewhere in this
file (e.g. ``except Exception:  # pragma: no cover`` on line 143
inside ``_on_done``).

…says are reached

Third CI round: coverage reached 100.00% on the previous commit, but
the project also runs ``strict-no-cover`` which complains when a
line is marked ``# pragma: no cover`` yet actually gets hit by the
test suite (it prevents coverage rot from creeping in under pragma
cover).

It flagged two of my pragmas:
  src/mcp/client/stdio.py:161 — `except asyncio.CancelledError:`
  src/mcp/client/stdio.py:163 — `except anyio.ClosedResourceError:`

Both are reached on Linux during the normal teardown of the new
stdio tests, so the pragma was wrong. Removed them. (The Windows
runs did not hit these branches — which explains why Windows matrix
passed last round but Linux did not; strict-no-cover runs on the
Linux jobs.)

Kept the pragmas on lines 131, 155, 166 — those are the defensive
branches that still are not reached by any existing test on either
platform and still warrant the marker.

15 stdio tests pass locally; ruff + pyright clean.

…dependent exception catches

The two catches I touched in the previous commit
(``except asyncio.CancelledError`` and
``except anyio.ClosedResourceError`` in the teardown result-collection
loop) turn out to be timing-dependent:

  - On Windows the teardown of the background reader/writer finishes
    before the loop reaches ``await task``, so ``await task`` never
    raises CancelledError / ClosedResourceError and the branches are
    unreached — needs pragma.
  - On some Linux runs the reader/writer is still running when we
    cancel and await, so the branches *are* reached — strict-no-cover
    complained that a plain ``pragma: no cover`` was wrong there.

Switched both to ``pragma: lax no cover``, which the project's
coverage config already defines as the opt-out marker for exactly
this case (exists on other lines in the same file, e.g. 247).
It is excluded from coverage reporting but does not trip
strict-no-cover when the line happens to be hit.