fix(call-to-play): resync after live delivery failure

A failed fire-and-forget event left one peer's active call state divergent until
some later discovery or reconnect happened. During a LAN party that could leave
different players looking at different rosters or chat.

Fall back to the existing bidirectional handshake whenever a live Call to Play
send fails. Its active-history exchange heals both sides immediately when the
failure was transient. Document the related wall-clock synchronization
assumption for deadline and countdown presentation.

Test Plan:
- `just fmt` -- passed
- `just clippy` -- passed
- `just test` -- passed, 147 peer tests
- `just peer-cli-tests S48` -- passed
- `git diff --cached --check` -- passed

crates/lanspread-peer/src/call_to_play.rs

@@ -8,7 +8,13 @@ use std::{
 use lanspread_proto::{CallToPlayAction, CallToPlayEvent};
 use tokio::sync::mpsc::UnboundedSender;
 
-use crate::{PeerEvent, context::Ctx, events, network::send_call_to_play_events};
+use crate::{
+    PeerEvent,
+    context::Ctx,
+    events,
+    network::send_call_to_play_events,
+    services::{HandshakeCtx, perform_handshake_with_peer},
+};
 
 const MAX_EVENTS: usize = 4_096;
 const MAX_ID_CHARS: usize = 128;
@@ -173,15 +179,24 @@ pub(crate) async fn publish(
 
     let peer_addresses = ctx.peer_game_db.read().await.get_peer_addresses();
     let peer_id = ctx.peer_id.clone();
+    let handshake_ctx = HandshakeCtx::from_ctx(ctx, tx_notify_ui);
     ctx.task_tracker.spawn(async move {
         let deliveries = peer_addresses.into_iter().map(|peer_addr| {
             let event = event.clone();
             let peer_id = peer_id.clone();
+            let handshake_ctx = handshake_ctx.clone();
             async move {
                 if let Err(err) =
                     send_call_to_play_events(peer_addr, peer_id.as_ref(), vec![event]).await
                 {
                     log::warn!("Failed to send Call to Play event to {peer_addr}: {err}");
+                    if let Err(resync_err) =
+                        perform_handshake_with_peer(handshake_ctx, peer_addr, None).await
+                    {
+                        log::warn!(
+                            "Failed to resync Call to Play history with {peer_addr}: {resync_err}"
+                        );
+                    }
                 }
             }
         });