fix(peer): drain streamed install senders after completion

A streamed install sender kept the original frame sink alive outside the
producer task. After the producer sent Complete, or an Error for a provider
failure, the forwarding loop still had a live mpsc sender in scope and waited
forever for another frame.

Move the sink into the producer so the channel closes when the producer exits.
That lets the QUIC writer close, the request task return, and the outbound
TransferGuard drop after successful streamed installs and provider-side
failures.

The peer-cli harness now keeps the outbound-transfer map it passes into the
peer runtime and exposes per-game counts in status. S39 asserts that the source
has no active outbound transfer for cnctw after the streamed install finishes,
which catches the sender-side lifecycle leak that receiver-only assertions
missed. The peer-cli README and scenario table document that status field and
expectation.

Test Plan:
- just fmt
- just test
- just clippy
- git diff --check
- git diff --cached --check
- python3 crates/lanspread-peer-cli/scripts/run_extended_scenarios.py S39 S40 --build-image
- python3 crates/lanspread-peer-cli/scripts/run_extended_scenarios.py S41 S42 S43 S44 S45 S46 S47

Refs: NEXT_STEPS.md streamed install lifecycle hardening

crates/lanspread-peer-cli/scripts/run_extended_scenarios.py

@@ -1270,9 +1270,11 @@ class Runner:
                 f"streamed byte count mismatch: {streamed_bytes} != {expected_bytes}"
             )
 
+        wait_no_outbound_transfer(source, "cnctw")
+
         return (
             "cnctw streamed into local/ only; root archive and version.ini absent; "
-            f"payload hashes={actual}"
+            f"payload hashes={actual}; source outbound transfer drained"
         )
 
     def s40_streamed_receiver_not_source(self) -> str:
@@ -1865,6 +1867,20 @@ def wait_no_active(peer: Peer, game_id: str, timeout: float = 20) -> None:
     raise ScenarioError(f"{peer.name} still has active operation for {game_id}: {last_active}")
 
 
+def wait_no_outbound_transfer(peer: Peer, game_id: str, timeout: float = 20) -> None:
+    deadline = time.monotonic() + timeout
+    last_active: dict[str, int] = {}
+    while time.monotonic() < deadline:
+        active = peer.status()["active_outbound_transfers"]
+        last_active = active
+        if active.get(game_id, 0) == 0:
+            return
+        time.sleep(0.4)
+    raise ScenarioError(
+        f"{peer.name} still has outbound transfer for {game_id}: {last_active}"
+    )
+
+
 def assert_game_state(
     game: dict[str, Any],
     *,