refactor(peer): extract peer startup task spawning

The peer runtime used to spawn each long-running service inline inside
run_peer. That made the startup path harder to scan because service names,
clone setup, and task error handling were interleaved with the command loop.

Move the task wrappers into a startup module and leave run_peer as the
lifecycle overview: create shared context, start services, handle commands,
then send shutdown goodbyes. The spawned services and their error handling are
unchanged; only the ownership plumbing moved into named helpers.

Test Plan:
- cargo clippy
- cargo clippy --benches
- cargo clippy --tests
- cargo +nightly fmt

Refs: none

crates/lanspread-peer/src/startup.rs

@@ -0,0 +1,116 @@
+//! Peer runtime task startup and shutdown orchestration.
+
+use std::{net::SocketAddr, sync::Arc};
+
+use tokio::sync::{
+    RwLock,
+    mpsc::{UnboundedReceiver, UnboundedSender},
+};
+
+use crate::{
+    PeerCommand,
+    PeerEvent,
+    context::Ctx,
+    network::send_goodbye,
+    peer_db::PeerGameDB,
+    run_peer,
+    services::{
+        run_local_game_monitor,
+        run_peer_discovery,
+        run_ping_service,
+        run_server_component,
+    },
+};
+
+const EPHEMERAL_SERVER_ADDR: &str = "0.0.0.0:0";
+
+pub(crate) fn spawn_peer_runtime(
+    rx_control: UnboundedReceiver<PeerCommand>,
+    tx_notify_ui: UnboundedSender<PeerEvent>,
+    peer_game_db: Arc<RwLock<PeerGameDB>>,
+    peer_id: String,
+) {
+    tokio::spawn(async move {
+        if let Err(err) = run_peer(rx_control, tx_notify_ui, peer_game_db, peer_id).await {
+            log::error!("Peer system failed: {err}");
+        }
+    });
+}
+
+pub(crate) fn spawn_startup_services(
+    ctx: &Ctx,
+    tx_notify_ui: &UnboundedSender<PeerEvent>,
+) -> eyre::Result<()> {
+    spawn_quic_server(ctx, tx_notify_ui)?;
+    spawn_peer_discovery_service(ctx, tx_notify_ui);
+    spawn_peer_liveness_service(ctx, tx_notify_ui);
+    spawn_local_library_monitor(ctx, tx_notify_ui);
+
+    Ok(())
+}
+
+pub(crate) async fn spawn_goodbye_notifications(ctx: &Ctx) {
+    let peer_id = ctx.peer_id.as_ref().clone();
+    let peer_addresses = { ctx.peer_game_db.read().await.get_peer_addresses() };
+
+    for peer_addr in peer_addresses {
+        spawn_goodbye_notification(peer_addr, peer_id.clone());
+    }
+}
+
+fn spawn_quic_server(ctx: &Ctx, tx_notify_ui: &UnboundedSender<PeerEvent>) -> eyre::Result<()> {
+    let server_addr = EPHEMERAL_SERVER_ADDR.parse::<SocketAddr>()?;
+    let peer_ctx = ctx.to_peer_ctx(tx_notify_ui.clone());
+    let tx_notify_ui = tx_notify_ui.clone();
+
+    tokio::spawn(async move {
+        if let Err(err) = run_server_component(server_addr, peer_ctx, tx_notify_ui).await {
+            log::error!("Server component error: {err}");
+        }
+    });
+
+    Ok(())
+}
+
+fn spawn_peer_discovery_service(ctx: &Ctx, tx_notify_ui: &UnboundedSender<PeerEvent>) {
+    let ctx = ctx.clone();
+    let tx_notify_ui = tx_notify_ui.clone();
+
+    tokio::spawn(async move {
+        run_peer_discovery(tx_notify_ui, ctx).await;
+    });
+}
+
+fn spawn_peer_liveness_service(ctx: &Ctx, tx_notify_ui: &UnboundedSender<PeerEvent>) {
+    let tx_notify_ui = tx_notify_ui.clone();
+    let peer_game_db = ctx.peer_game_db.clone();
+    let downloading_games = ctx.downloading_games.clone();
+    let active_downloads = ctx.active_downloads.clone();
+
+    tokio::spawn(async move {
+        run_ping_service(
+            tx_notify_ui,
+            peer_game_db,
+            downloading_games,
+            active_downloads,
+        )
+        .await;
+    });
+}
+
+fn spawn_local_library_monitor(ctx: &Ctx, tx_notify_ui: &UnboundedSender<PeerEvent>) {
+    let ctx = ctx.clone();
+    let tx_notify_ui = tx_notify_ui.clone();
+
+    tokio::spawn(async move {
+        run_local_game_monitor(tx_notify_ui, ctx).await;
+    });
+}
+
+fn spawn_goodbye_notification(peer_addr: SocketAddr, peer_id: String) {
+    tokio::spawn(async move {
+        if let Err(err) = send_goodbye(peer_addr, peer_id).await {
+            log::warn!("Failed to send Goodbye to {peer_addr}: {err}");
+        }
+    });
+}