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/services/discovery.rs

@@ -11,7 +11,7 @@ use crate::{
     context::Ctx,
     events,
     peer_db::PeerId,
-    services::{handshake::perform_handshake_with_peer, legacy::request_games_from_peer},
+    services::handshake::perform_handshake_with_peer,
 };
 
 struct MdnsPeerInfo {
@@ -128,10 +128,22 @@ async fn handle_discovered_peer(
     ctx: &Ctx,
     tx_notify_ui: &UnboundedSender<PeerEvent>,
 ) {
-    let peer_id = info
-        .peer_id
-        .clone()
-        .unwrap_or_else(|| format!("legacy-{}", info.addr));
+    if info.proto_ver != Some(PROTOCOL_VERSION) {
+        log::debug!(
+            "Ignoring peer at {} with protocol {:?}; expected {PROTOCOL_VERSION}",
+            info.addr,
+            info.proto_ver
+        );
+        return;
+    }
+
+    let Some(peer_id) = info.peer_id.clone() else {
+        log::debug!(
+            "Ignoring current-protocol peer at {} without a peer_id TXT record",
+            info.addr
+        );
+        return;
+    };
 
     let upsert = {
         let mut db = ctx.peer_game_db.write().await;
@@ -160,30 +172,22 @@ fn spawn_protocol_negotiation(
     peer_id: PeerId,
 ) {
     let peer_addr = info.addr;
-    let proto_ver = info.proto_ver;
     let peer_id_arc = ctx.peer_id.clone();
     let local_library = ctx.local_library.clone();
     let peer_game_db = ctx.peer_game_db.clone();
 
     ctx.task_tracker.spawn(async move {
-        let handshake_result = if proto_ver.is_none() || proto_ver == Some(PROTOCOL_VERSION) {
-            perform_handshake_with_peer(
-                peer_id_arc,
-                local_library,
-                peer_game_db.clone(),
-                tx_notify_ui.clone(),
-                peer_addr,
-                Some(peer_id),
-            )
-            .await
-        } else {
-            Err(eyre::eyre!("Skipping hello for legacy peer"))
-        };
-
-        if handshake_result.is_err()
-            && let Err(err) = request_games_from_peer(peer_addr, tx_notify_ui, peer_game_db).await
+        if let Err(err) = perform_handshake_with_peer(
+            peer_id_arc,
+            local_library,
+            peer_game_db,
+            tx_notify_ui,
+            peer_addr,
+            Some(peer_id),
+        )
+        .await
         {
-            log::error!("Failed to request games from peer {peer_addr}: {err}");
+            log::warn!("Failed to negotiate protocol with peer {peer_addr}: {err}");
         }
     });
 }