feat(peer): prototype streamed installs

Add a streamed-install prototype that can receive archive-derived install bytes
straight into local/ without first storing the peer-owned root archive payload.
This is intended for low-disk clients that want to install a game but opt out of
becoming a downloadable peer source for that game.

The protocol gains a current-version-only StreamInstall request and framed
StreamInstallFrame responses. The peer core owns the generic transport,
transaction, path validation, size checks, CRC32 verification, and lifecycle
state. The archive-specific work is hidden behind StreamInstallProvider so the
prototype can use unrar while the final implementation can swap in a better
provider without rewriting the peer command path.

The receiver writes into .local.installing and only promotes to local/ after the
full stream verifies. It deliberately does not write the root version.ini or
archive files, so the settled local state is installed=true, downloaded=false,
and availability=LocalOnly. That preserves the existing rule that local/ is not
served to peers and makes streamed receivers non-sources by construction.

The CLI is the only caller for now. It exposes stream-install and provides the
prototype unrar implementation with unrar lt for entry metadata and unrar p for
file bytes. This is simple and good enough to prove non-solid archive streaming,
but it is not the production provider shape for solid archives because per-file
unrar p would repeatedly decompress prefixes. The Tauri app explicitly passes
stream_install_provider: None, so the GUI behavior stays unchanged until a real
product path is designed.

Document the production-readiness work in NEXT_STEPS.md. The main follow-up is
to make the provider abstraction final-ish and replace the per-file CLI unrar
provider with a one-pass archive provider, then wire a deliberate GUI low-disk
mode, retry semantics, and broader failure scenarios.

Test Plan:
- just fmt
- RUSTC_WRAPPER= CARGO_BUILD_RUSTC_WRAPPER= just test
- python3 crates/lanspread-peer-cli/scripts/run_extended_scenarios.py \
  S39 S40 --build-image
- RUSTC_WRAPPER= CARGO_BUILD_RUSTC_WRAPPER= just clippy
- git diff --check
- git diff --cached --check

Follow-up: NEXT_STEPS.md

crates/lanspread-peer-cli/src/main.rs

@@ -17,6 +17,7 @@ use lanspread_peer::{
     ActiveOperation,
     ActiveOperationKind,
     InstallOperation,
+    NoopStreamInstallProvider,
     PeerCommand,
     PeerEvent,
     PeerGameDB,
@@ -24,6 +25,7 @@ use lanspread_peer::{
     PeerRuntimeHandle,
     PeerSnapshot,
     PeerStartOptions,
+    StreamInstallProvider,
     migrate_legacy_state,
     start_peer_with_options,
 };
@@ -31,6 +33,7 @@ use lanspread_peer_cli::{
     CliCommand,
     CommandEnvelope,
     DEFAULT_FIXTURE_VERSION,
+    ExternalUnrarStreamProvider,
     ExternalUnrarUnpacker,
     FixtureSeed,
     FixtureUnpacker,
@@ -134,10 +137,15 @@ async fn main() -> eyre::Result<()> {
     let (tx_events, rx_events) = mpsc::unbounded_channel();
     let peer_game_db = Arc::new(RwLock::new(PeerGameDB::new()));
     let catalog = Arc::new(RwLock::new(catalog));
-    let unpacker: Arc<dyn lanspread_peer::Unpacker> = match args.unrar {
+    let unrar_for_streaming = args.unrar.clone().or_else(default_unrar_program);
+    let unpacker: Arc<dyn lanspread_peer::Unpacker> = match args.unrar.clone() {
         Some(path) => Arc::new(ExternalUnrarUnpacker::new(path)),
         None => Arc::new(FixtureUnpacker),
     };
+    let stream_install_provider: Arc<dyn StreamInstallProvider> = match unrar_for_streaming {
+        Some(path) => Arc::new(ExternalUnrarStreamProvider::new(path)),
+        None => Arc::new(NoopStreamInstallProvider),
+    };
 
     let mut handle = start_peer_with_options(
         args.games_dir.clone(),
@@ -148,6 +156,7 @@ async fn main() -> eyre::Result<()> {
         PeerStartOptions {
             state_dir: Some(args.state_dir.clone()),
             active_outbound_transfers: None,
+            stream_install_provider: Some(stream_install_provider),
         },
     )?;
     let sender = handle.sender();
@@ -249,6 +258,15 @@ async fn handle_command(
             })?;
             Ok(json!({"queued": true, "game_id": game_id, "install": install_after_download}))
         }
+        CliCommand::StreamInstall { game_id } => {
+            ensure_catalog_game(shared, game_id).await?;
+            ensure_no_active_operation(shared, game_id).await?;
+            let _ = game_files_for_download(sender, shared, game_id).await?;
+            sender.send(PeerCommand::StreamInstallGame {
+                id: game_id.clone(),
+            })?;
+            Ok(json!({"queued": true, "game_id": game_id}))
+        }
         CliCommand::Install { game_id } => {
             ensure_catalog_game(shared, game_id).await?;
             ensure_no_active_operation(shared, game_id).await?;
@@ -729,6 +747,15 @@ fn default_catalog_db() -> Option<PathBuf> {
     .find(|path| path.exists())
 }
 
+fn default_unrar_program() -> Option<PathBuf> {
+    [
+        PathBuf::from("/usr/local/bin/unrar"),
+        PathBuf::from("/usr/bin/unrar"),
+    ]
+    .into_iter()
+    .find(|path| path.exists())
+}
+
 fn next_string(args: &mut impl Iterator<Item = OsString>, flag: &str) -> eyre::Result<String> {
     args.next()
         .ok_or_else(|| eyre::eyre!("{flag} requires a value"))?