Add per-routine target heart rate with live in-run indicator

Endurance routines (HIIT, cardio, cycling) can carry an optional target bpm
(RoutineDocument.targetHeartRate, not schema-bumped — same preference-field
rationale as restSeconds/autoAdvance), snapshotted onto the WorkoutDocument at
plan time like the other pacing fields.

During a run, the watch streams its live HR sample to the phone over a new
best-effort liveHeartRate message — deliberately outside the LiveProgress
machinery (no version bump, no staging/retry; a gauge, not a record), throttled
to changed-bpm-or-10s in the watch bridge. LiveRunState holds the sample with a
30s staleness auto-clear so a dead stream never shows a frozen number.

Both run screens show the reading only when the run carries a target: the
phone's ExerciseProgressView as a top pill, the watch's in the top-trailing
toolbar slot, each tinted by a shared ±5 bpm HeartRateBand with an arrow cue to
push harder (low) or ease off (high) — e.g. dialing in a treadmill incline to
hold a steady effort.

Claude-Session: https://claude.ai/code/session_01Y7ZhkCYWNiTSAFhFCGnJ8n

Workouts Watch App/Connectivity/WatchConnectivityBridge.swift

@@ -217,6 +217,28 @@ final class WatchConnectivityBridge: NSObject {
         }
     }
 
+    // MARK: - Live heart rate (ephemeral; best-effort)
+
+    /// Rounded bpm last sent and when, to throttle the forward: HR samples land every few
+    /// seconds, but an unchanged reading only needs an occasional keep-alive so the phone's
+    /// staleness window doesn't blank the readout mid-run.
+    private var lastHRSentBpm: Int?
+    private var lastHRSentAt = Date.distantPast
+
+    /// Forward a live heart-rate sample to a mirroring phone. Unlike the run frames this is
+    /// pure best-effort — reachable-only, no staging, no retry: a gauge, not a record. The
+    /// durable HR summary still lands in `WorkoutMetrics` when the session finishes.
+    func sendLiveHeartRate(_ bpm: Double) {
+        guard let session, session.activationState == .activated, session.isReachable else { return }
+        let rounded = Int(bpm.rounded())
+        let now = Date()
+        if rounded == lastHRSentBpm, now.timeIntervalSince(lastHRSentAt) < 10 { return }
+        lastHRSentBpm = rounded
+        lastHRSentAt = now
+        session.sendMessage(WCPayload.encodeLiveHeartRate(bpm: bpm, at: now),
+                            replyHandler: nil, errorHandler: nil)
+    }
+
     /// Apply a live-run frame the phone sent. Catches our send counter up first (shared per-run
     /// sequence), then arbitrates against our own staged outbound frame for the same run: if the
     /// incoming frame outranks it, drop the staged one (so a later reconnect can't re-send stale