Workouts 2.0: re-base persistence on iCloud Drive documents

Replace Core Data + NSPersistentCloudKitContainer + App-Group store +
WatchConnectivity dictionary sync with the QuickRabbit iCloud-documents
architecture:

- iCloud Drive JSON documents are the sole source of truth (one file per
  aggregate: Splits/<ULID>.json, Workouts/YYYY/MM/<ULID>.json), with a
  rebuildable SwiftData cache populated only by an NSMetadataQuery observer
  and a connect-time reconcile. Soft-delete tombstones; hard iCloud gate.
- Shared model layer (ULID, Codable *Documents + stateless mappers, @Model
  cache entities, SwiftData container) compiled into both targets.
- New iPhone<->Watch bridge over WatchConnectivity keyed by ULIDs; the phone
  is the sole writer of iCloud Drive, the watch round-trips documents.
- AppServices DI + iCloud-required root gate; Swift 6 strict concurrency.
- Starter splits generated on demand from the bundled YAML catalogs.
- Migrate to XcodeGen (project.yml), iOS 26 / watchOS 26; CloudDocuments
  entitlement (drop CloudKit/App Group/aps-environment).
- Duration stored as Int seconds (was a Date epoch hack); fix workout
  end-on-create, undismissable delete dialog, toolbar-hiding nav stacks,
  and the Settings placeholder.
- Add README/CHANGELOG/LICENSE, .gitignore, refreshed REQUIREMENTS, and the
  Scripts/ TestFlight pipeline (release.sh + ASC API scripts).

MARKETING_VERSION 2.0.

Workouts Watch App/Connectivity/WatchConnectivityBridge.swift

@@ -0,0 +1,98 @@
+import Foundation
+import Observation
+import SwiftData
+import WatchConnectivity
+
+/// Watch side of the iPhone↔Watch bridge. The watch never touches iCloud — it
+/// keeps a local SwiftData cache fed only by application-context pushes from the
+/// phone, updates it optimistically on local edits, and forwards changed workouts
+/// to the phone (which is the sole writer of iCloud Drive).
+@Observable
+@MainActor
+final class WatchConnectivityBridge: NSObject {
+    private let container: ModelContainer
+    private var session: WCSession?
+
+    /// Last time state was received from the phone (for a sync indicator).
+    private(set) var lastSyncDate: Date?
+
+    private var context: ModelContext { container.mainContext }
+
+    init(container: ModelContainer) {
+        self.container = container
+        super.init()
+    }
+
+    func activate() {
+        guard WCSession.isSupported() else { return }
+        let session = WCSession.default
+        session.delegate = self
+        session.activate()
+        self.session = session
+        // Apply whatever the phone last pushed, then ask for a fresh push.
+        applyState(WCPayload.decodeSplits(session.receivedApplicationContext),
+                   workouts: WCPayload.decodeWorkouts(session.receivedApplicationContext))
+        requestSync()
+    }
+
+    func requestSync() {
+        guard let session, session.activationState == .activated, session.isReachable else { return }
+        session.sendMessage(WCPayload.requestSyncMessage(), replyHandler: nil, errorHandler: nil)
+    }
+
+    /// Optimistically applies a workout edit to the local cache and forwards it to
+    /// the phone for durable persistence in iCloud Drive.
+    func update(workout doc: WorkoutDocument) {
+        CacheMapper.upsertWorkout(doc, relativePath: doc.relativePath, into: context)
+        try? context.save()
+        sendToPhone(doc)
+    }
+
+    // MARK: - Internal
+
+    private func sendToPhone(_ doc: WorkoutDocument) {
+        guard let session, session.activationState == .activated else { return }
+        let payload = WCPayload.encodeWorkoutUpdate(doc)
+        if session.isReachable {
+            session.sendMessage(payload, replyHandler: nil, errorHandler: { _ in
+                session.transferUserInfo(payload)   // fall back to guaranteed delivery
+            })
+        } else {
+            session.transferUserInfo(payload)
+        }
+    }
+
+    private func applyState(_ splits: [SplitDocument], workouts: [WorkoutDocument]) {
+        guard !splits.isEmpty || !workouts.isEmpty else { return }
+        var liveSplitIDs = Set<String>()
+        for s in splits {
+            CacheMapper.upsertSplit(s, relativePath: s.relativePath, into: context)
+            liveSplitIDs.insert(s.id)
+        }
+        for w in workouts {
+            CacheMapper.upsertWorkout(w, relativePath: w.relativePath, into: context)
+        }
+        // Splits are sent in full → prune any the phone no longer has. Workouts are
+        // sent as a recent window, so they're upserted but never pruned (avoids a
+        // race deleting a workout just created on the watch).
+        if let allSplits = try? context.fetch(FetchDescriptor<Split>()) {
+            for s in allSplits where !liveSplitIDs.contains(s.id) { context.delete(s) }
+        }
+        try? context.save()
+        lastSyncDate = Date()
+    }
+}
+
+// MARK: - WCSessionDelegate
+
+extension WatchConnectivityBridge: WCSessionDelegate {
+    nonisolated func session(_ session: WCSession, activationDidCompleteWith activationState: WCSessionActivationState, error: Error?) {
+        Task { @MainActor in self.requestSync() }
+    }
+
+    nonisolated func session(_ session: WCSession, didReceiveApplicationContext applicationContext: [String: Any]) {
+        let splits = WCPayload.decodeSplits(applicationContext)
+        let workouts = WCPayload.decodeWorkouts(applicationContext)
+        Task { @MainActor in self.applyState(splits, workouts: workouts) }
+    }
+}