Make the live-run mirror survive lost phone-to-watch frames

Live frames ride sendMessage, which is reachable-only — and phone→watch
reachability drops exactly when the user is swiping on the phone (wrist
down). A frame that failed to send was staged but never retried until a
reachability edge, and a frame lost outright desynced the run until the
next human transition — sometimes forever, since a reconnect could even
re-send the stale staged frame and yank the peer backwards.

Four fixes, symmetric on both bridges and both run screens:

- A send that fails while nominally reachable now retries with a short
  backoff (a few times per staged message) instead of being swallowed.
- Receiving a frame that outranks the staged outbound one drops the
  staged frame, so a reconnect re-send can't move the run backwards;
  a delivery the staged frame outranks is ignored as stale.
- Every staleness comparison now tie-breaks the shared version sequence
  on the frame's wall-clock anchor (LiveProgress.isNewer) — after a
  lost frame both devices can mint the same version, and the later
  human action must win.
- Durable repair: when the absorbed workout doc shows sets completed
  beyond anything the open run screen recorded or followed, it jumps
  forward to the first unfinished set's work page — a lost frame now
  degrades to a briefly-stale page instead of a stuck one.

Shared/Connectivity/LiveProgress.swift

@@ -48,3 +48,19 @@ struct LiveProgress: Sendable, Equatable {
     /// Monotonic per-run sequence, so the mirror can drop a stale / out-of-order delivery.
     var version: Int
 }
+
+extension LiveProgress {
+    /// Strict "newer than" over the shared per-run sequence, tie-broken by the phase anchor.
+    /// The tie-break matters because the sequence isn't collision-free: each side catches its
+    /// counter up only from frames it *receives*, so after a lost frame both devices can mint
+    /// the same version independently. On a collision the later wall-clock action wins —
+    /// paired-device clock skew is sub-second, so the anchor orders genuine collisions
+    /// correctly. Equal version *and* equal anchor is the same frame redelivered: not newer.
+    func isNewer(thanVersion version: Int, start: Date) -> Bool {
+        self.version != version ? self.version > version : phaseStart > start
+    }
+
+    func isNewer(than other: LiveProgress) -> Bool {
+        isNewer(thanVersion: other.version, start: other.phaseStart)
+    }
+}