Guard double-terminate on returncode; make _terminate_and_reap idempotent

Addresses review feedback: calling _terminate_process_tree on an
already-reaped POSIX process hits the fallback path in
terminate_posix_process_tree (os.getpgid on a stale PID raises
ProcessLookupError), which emits two WARNING logs and an ERROR with
traceback. These are visible because pyproject.toml sets log_cli=true.

Previously, each test called _terminate_process_tree in the body and the
AsyncExitStack called _terminate_and_reap (which re-called
_terminate_process_tree) at exit — double-terminate, nine spurious log
records per run.

Fix: _terminate_and_reap now checks proc.returncode before terminating.
On POSIX, the asyncio child watcher sets returncode during
_terminate_process_tree's polling-loop yield, so by the time cleanup
runs it's populated and the guard skips the noisy re-terminate. On
Windows/FallbackProcess (no returncode attribute), getattr returns None
and terminate runs — but the Windows path is silent on double-call.

Restructured tests to call _terminate_and_reap (which wraps
_terminate_process_tree) as the action under test, and let the ExitStack
safety-net call it again. Since wait() and stream.aclose() are
idempotent, this is safe — and it covers both branches of the guard
(first call: returncode is None → terminate; second call: returncode set
→ skip). 100% coverage, still zero pragmas.

Github-Issue: #1775

Author: maxisbey

tests/client/test_stdio.py

@@ -321,11 +321,17 @@ async def _terminate_and_reap(proc: anyio.abc.Process | FallbackProcess) -> None
     reaping + stream closure. These tests call ``_terminate_process_tree``
     directly, so they must do the same cleanup explicitly.
 
-    Safe to call on an already-terminated process (termination no-ops, wait
-    returns immediately). Bounded by ``move_on_after`` to prevent hangs.
+    Idempotent: the ``returncode`` guard skips termination if the process has
+    already been reaped (calling ``_terminate_process_tree`` on a reaped POSIX
+    process hits the fallback path in ``terminate_posix_process_tree`` and emits
+    spurious WARNING/ERROR logs, visible because ``log_cli = true``); ``wait()``
+    and stream ``aclose()`` are no-ops on subsequent calls. The tests call this
+    explicitly as the action under test, and ``AsyncExitStack`` calls it again
+    on exit as a safety net for early failures. Bounded by ``move_on_after``.
     """
     with anyio.move_on_after(5.0):
-        await _terminate_process_tree(proc)
+        if getattr(proc, "returncode", None) is None:
+            await _terminate_process_tree(proc)
         await proc.wait()
         assert proc.stdin is not None
         assert proc.stdout is not None
@@ -356,8 +362,9 @@ async def test_basic_child_process_cleanup(self):
                 stream = await _accept_alive(sock)
             stack.push_async_callback(stream.aclose)
 
-            # Terminate the process tree (the behavior under test).
-            await _terminate_process_tree(proc)
+            # Terminate, reap and close transports (wraps _terminate_process_tree,
+            # the behavior under test).
+            await _terminate_and_reap(proc)
 
             # Deterministic: kernel closed child's socket when it died.
             await _assert_stream_closed(stream)
@@ -391,8 +398,8 @@ async def test_nested_process_tree(self):
                     stack.push_async_callback(stream.aclose)
                     streams.append(stream)
 
-            # Terminate the entire tree.
-            await _terminate_process_tree(proc)
+            # Terminate the entire tree (wraps _terminate_process_tree).
+            await _terminate_and_reap(proc)
 
             # Every level of the tree must be dead: three kernel-level EOFs.
             for stream in streams:
@@ -426,7 +433,7 @@ async def test_early_parent_exit(self):
 
             # Parent will sys.exit(0) on SIGTERM, but the process-group kill
             # (POSIX killpg / Windows Job Object) must still terminate the child.
-            await _terminate_process_tree(proc)
+            await _terminate_and_reap(proc)
 
             # Child must be dead despite parent's early exit.
             await _assert_stream_closed(stream)