fix(peer): settle current-protocol local state cleanup

The follow-up backlog had drifted into three settled peer/runtime issues: the
legacy game-list fallback contradicted the one-wire-version policy, the Tauri
shell still re-derived local install state from disk after peer snapshots, and
`Availability::Downloading` existed even though active operations are already
reported through a separate operation table.

Remove the legacy `AnnounceGames` request and fallback service. Discovery now
ignores peers that do not advertise the current protocol and a peer id, and
library changes are sent through the current delta path only. This keeps the
runtime aligned with the documented current-build-only interoperability model.

Make peer `LocalGamesUpdated` snapshots authoritative for local fields in the
Tauri database. The GUI-side catalog still owns static metadata such as names,
sizes, and descriptions, but downloaded, installed, local version, and
availability now come from the peer runtime instead of a second whole-library
filesystem scan. Snapshot reconciliation also pins the missing-begin and
missing-finish lifecycle cases in tests.

Collapse availability back to the settled `Ready` and `LocalOnly` states.
Aggregation now counts only `Ready` peers as download sources, and the frontend
no longer carries a dead `Downloading` enum value.

The core peer also exposes the small non-GUI hooks needed by scripted callers:
startup options for state and mDNS, a local-ready event, direct connection, peer
snapshots, and an explicit post-download install policy. Those hooks reuse the
same current protocol path and do not add compatibility shims.

Test Plan:
- `git diff --check`
- `just fmt`
- `just clippy`
- `just test`

Refs: BACKLOG.md, FINDINGS.md, IMPL_DECISIONS.md

crates/lanspread-peer/src/network.rs

@@ -123,39 +123,6 @@ pub async fn exchange_hello(peer_addr: SocketAddr, hello: Hello) -> eyre::Result
     }
 }
 
-/// Fetches the list of games from a peer.
-pub async fn fetch_games_from_peer(peer_addr: SocketAddr) -> eyre::Result<Vec<Game>> {
-    let mut conn = connect_to_peer(peer_addr).await?;
-
-    let stream = conn.open_bidirectional_stream().await?;
-    let (rx, tx) = stream.split();
-    let mut framed_rx = FramedRead::new(rx, LengthDelimitedCodec::new());
-    let mut framed_tx = FramedWrite::new(tx, LengthDelimitedCodec::new());
-
-    // Send ListGames request
-    framed_tx.send(Request::ListGames.encode()).await?;
-    let _ = framed_tx.close().await;
-
-    // Receive response
-    let mut data = BytesMut::new();
-    while let Some(Ok(bytes)) = framed_rx.next().await {
-        data.extend_from_slice(&bytes);
-    }
-
-    let response = Response::decode(data.freeze());
-    if let Response::ListGames(games) = response {
-        Ok(games)
-    } else {
-        log::warn!("Unexpected response from peer {peer_addr}: {response:?}");
-        Ok(Vec::new())
-    }
-}
-
-/// Announces local games to a peer.
-pub async fn announce_games_to_peer(peer_addr: SocketAddr, games: Vec<Game>) -> eyre::Result<()> {
-    send_oneway_request(peer_addr, Request::AnnounceGames(games)).await
-}
-
 pub async fn send_library_summary(
     peer_addr: SocketAddr,
     summary: LibrarySummary,
@@ -178,6 +145,33 @@ pub async fn send_goodbye(peer_addr: SocketAddr, peer_id: String) -> eyre::Resul
     send_oneway_request(peer_addr, Request::Goodbye { peer_id }).await
 }
 
+/// Requests the current game list from a peer.
+pub async fn request_game_list_from_peer(peer_addr: SocketAddr) -> eyre::Result<Vec<Game>> {
+    let mut conn = connect_to_peer(peer_addr).await?;
+
+    let stream = conn.open_bidirectional_stream().await?;
+    let (rx, tx) = stream.split();
+    let mut framed_rx = FramedRead::new(rx, LengthDelimitedCodec::new());
+    let mut framed_tx = FramedWrite::new(tx, LengthDelimitedCodec::new());
+
+    framed_tx.send(Request::ListGames.encode()).await?;
+    framed_tx.close().await?;
+
+    let mut data = BytesMut::new();
+    while let Some(Ok(bytes)) = framed_rx.next().await {
+        data.extend_from_slice(&bytes);
+    }
+
+    let response = Response::decode(data.freeze());
+    match response {
+        Response::ListGames(games) => Ok(games),
+        Response::InternalPeerError(error_msg) => {
+            eyre::bail!("peer {peer_addr} reported internal error: {error_msg}")
+        }
+        other => eyre::bail!("unexpected response from {peer_addr}: {other:?}"),
+    }
+}
+
 /// Requests game file details from a peer.
 pub async fn request_game_details_from_peer(
     peer_addr: SocketAddr,