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-peer/src/context.rs

@@ -1,18 +1,17 @@
 //! Shared context types for the peer system.
 
-use std::{
-    collections::{HashMap, HashSet},
-    net::SocketAddr,
-    path::PathBuf,
-    sync::Arc,
-};
+use std::{collections::HashMap, net::SocketAddr, path::PathBuf, sync::Arc};
 
-use lanspread_db::db::GameDB;
+use lanspread_db::db::{GameCatalog, GameDB};
 use tokio::sync::{RwLock, mpsc::UnboundedSender};
 use tokio_util::{sync::CancellationToken, task::TaskTracker};
 
 use crate::{PeerEvent, Unpacker, events, library::LocalLibraryState, peer_db::PeerGameDB};
 
+/// Thread-safe map of active outbound file transfers grouped by game ID.
+pub type OutboundTransfers = Arc<RwLock<HashMap<String, Vec<(u64, CancellationToken)>>>>;
+
+
 /// Mutating filesystem operation currently in flight for a game root.
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
 pub enum OperationKind {
@@ -40,10 +39,11 @@ pub struct Ctx {
     pub active_operations: Arc<RwLock<HashMap<String, OperationKind>>>,
     pub active_downloads: Arc<RwLock<HashMap<String, CancellationToken>>>,
     pub unpacker: Arc<dyn Unpacker>,
-    pub catalog: Arc<RwLock<HashSet<String>>>,
+    pub catalog: Arc<RwLock<GameCatalog>>,
     pub peer_id: Arc<String>,
     pub shutdown: CancellationToken,
     pub task_tracker: TaskTracker,
+    pub active_outbound_transfers: OutboundTransfers,
 }
 
 /// Context for peer connection handling.
@@ -55,11 +55,12 @@ pub struct PeerCtx {
     pub local_peer_addr: Arc<RwLock<Option<SocketAddr>>>,
     pub active_operations: Arc<RwLock<HashMap<String, OperationKind>>>,
     pub peer_game_db: Arc<RwLock<PeerGameDB>>,
-    pub catalog: Arc<RwLock<HashSet<String>>>,
+    pub catalog: Arc<RwLock<GameCatalog>>,
     pub peer_id: Arc<String>,
     pub tx_notify_ui: tokio::sync::mpsc::UnboundedSender<PeerEvent>,
     pub shutdown: CancellationToken,
     pub task_tracker: TaskTracker,
+    pub active_outbound_transfers: OutboundTransfers,
 }
 
 impl std::fmt::Debug for PeerCtx {
@@ -84,7 +85,8 @@ impl Ctx {
         unpacker: Arc<dyn Unpacker>,
         shutdown: CancellationToken,
         task_tracker: TaskTracker,
-        catalog: Arc<RwLock<HashSet<String>>>,
+        catalog: Arc<RwLock<GameCatalog>>,
+        active_outbound_transfers: OutboundTransfers,
     ) -> Self {
         Self {
             game_dir: Arc::new(RwLock::new(game_dir)),
@@ -100,6 +102,7 @@ impl Ctx {
             peer_id: Arc::new(peer_id),
             shutdown,
             task_tracker,
+            active_outbound_transfers,
         }
     }
 
@@ -120,6 +123,7 @@ impl Ctx {
             tx_notify_ui,
             shutdown: self.shutdown.clone(),
             task_tracker: self.task_tracker.clone(),
+            active_outbound_transfers: self.active_outbound_transfers.clone(),
         }
     }
 }