feat(peer): coordinate outbound transfers with local game mutations

Updating or removing a local game rewrites its on-disk files. Peers that
were mid-download of that game would keep streaming bytes from files that
are being deleted or replaced, handing them a corrupt or stale copy.
There was also no authoritative notion of which game version a peer
should serve or accept, so a peer could serve whatever happened to be on
disk and downloaders could aggregate files from peers running mismatched
versions.

This introduces a reader-writer coordination scheme between outbound file
transfers (readers) and local mutation operations (writers), and gates
both serving and downloading on an authoritative game catalog version.

Reader-writer coordination:
- Track active outbound transfers per game in a shared `OutboundTransfers`
  map of (id, CancellationToken), threaded through `Ctx`/`PeerCtx` and
  registered by a `TransferGuard` in the stream service. The guard is
  registered *before* the serve-eligibility check to close a TOCTOU window
  where a writer could miss an in-flight reader.
- `stream_file_bytes` now honors a cancellation token at every await point
  (file read, network send, stream close) via `tokio::select!`, so a
  transfer aborts promptly instead of hanging on a stalled receiver.
- `begin_operation` marks a game active first, then cancels its outbound
  transfers and waits for the count to reach zero before any
  Updating/RemovingDownload work touches the filesystem.
- Active games are now hidden from library snapshots entirely while an
  operation is in flight, instead of freezing their last announced state,
  so peers stop discovering a game that is being mutated.

Authoritative version catalog:
- Replace the `HashSet<String>` catalog with `GameCatalog`, mapping each
  game id to its expected version (from the bundled game.db / ETI data).
- Serving requires the local `version.ini` to match the catalog version
  (`local_download_matches_catalog`); peer selection, file aggregation,
  and majority size validation all filter on the expected version
  (`peers_with_expected_version`, `aggregated_game_files`, and friends).

User-visible changes:
- The GUI shows confirmation dialogs before Update and Remove, and
  surfaces a sharing-status indicator on game cards and the detail modal.
- A new `OutboundTransferCountChanged` event lets the UI reflect live
  outbound transfer activity.

Test Plan:
- just test
- just frontend-test
- just clippy

crates/lanspread-tauri-deno-ts/src/lib/gameState.ts

@@ -88,17 +88,30 @@ export const isUnavailable = (game: Game): boolean =>
     && game.peer_count === 0
     && game.install_status === InstallStatus.NotInstalled;
 
+const parseVersionStamp = (version: string | undefined): number | null => {
+    if (!version || !/^\d{8}$/.test(version)) return null;
+    const parsed = parseInt(version, 10);
+    return Number.isNaN(parsed) ? null : parsed;
+};
+
+export const compareVersionStamps = (
+    left: string | undefined,
+    right: string | undefined,
+): number | null => {
+    const parsedLeft = parseVersionStamp(left);
+    const parsedRight = parseVersionStamp(right);
+    if (parsedLeft === null || parsedRight === null) return null;
+    return parsedLeft - parsedRight;
+};
+
+export const hasNewerLocalVersion = (game: Game): boolean =>
+    (compareVersionStamps(game.local_version, game.eti_game_version) ?? 0) > 0;
+
 export const needsUpdate = (game: Game): boolean => {
     if (!game.installed) return false;
-    const peer = game.eti_game_version;
-    const local = game.local_version;
-    if (!local && peer) return true;
-    if (local && peer) {
-        const l = parseInt(local, 10);
-        const p = parseInt(peer, 10);
-        if (!Number.isNaN(l) && !Number.isNaN(p)) return p > l;
-    }
-    return false;
+    if (game.peer_count <= 0) return false;
+    if (!game.local_version && game.eti_game_version) return true;
+    return (compareVersionStamps(game.eti_game_version, game.local_version) ?? 0) > 0;
 };
 
 /** What pressing the card's main action button should do, given the state. */