Fix rebucketing, seed upgrades, watch pruning, end re-stamping; add model tests

Editing a workout's start date now removes the file at its old month
bucket so the record no longer duplicates on the next reconcile. Seed
reconcile re-checks the tombstone veto before overwriting an upgraded
seed. The watch applies authoritative-empty pushes so remote deletes
prune, and a re-saved finished workout keeps its original end time.
Adds unit tests for the mappers, path bucketing, and status machine.

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

WorkoutsTests/WorkoutPathBucketingTests.swift

@@ -0,0 +1,86 @@
+import Foundation
+import Testing
+import IndieSync
+@testable import Workouts
+
+/// Pins `WorkoutDocument.relativePath` — the `Workouts/YYYY/MM/<ULID>.json` month
+/// bucketing that decides where every workout file lives. The bucket derives from
+/// `start` through a gregorian `Calendar`, which uses `TimeZone.current`, so the
+/// tests build their dates from explicit components in that same calendar and stay
+/// mid-month/mid-day (day 15, noon) so no real-world UTC offset (±14 h) can shift the
+/// month — making every assertion time-zone-independent. Also documents the orphan
+/// condition FIX-1 addresses in `SyncEngine.save(workout:)`: editing `start` across a
+/// month boundary re-buckets the SAME id to a new path.
+struct WorkoutPathBucketingTests {
+
+    /// A date fixed to the 15th at noon in the gregorian calendar's current time zone —
+    /// far enough from any month edge that the UTC-offset ambiguity can't move the month
+    /// (matches `DuplicateCleanupPlannerTests.fixedDate`). Decomposed by `relativePath`'s
+    /// own `Calendar(identifier: .gregorian)`, the year/month come back stable.
+    private func date(year: Int, month: Int, day: Int = 15, hour: Int = 12) -> Date {
+        var comps = DateComponents()
+        comps.year = year
+        comps.month = month
+        comps.day = day
+        comps.hour = hour
+        return Calendar(identifier: .gregorian).date(from: comps)!
+    }
+
+    @Test func bucketsByYearAndMonth() {
+        let path = WorkoutDocument.relativePath(id: "01ABC", start: date(year: 2024, month: 3))
+        #expect(path == "Workouts/2024/03/01ABC.json")
+    }
+
+    /// The month is zero-padded to two digits so lexical sort matches chronological sort.
+    @Test func padsSingleDigitMonth() {
+        #expect(WorkoutDocument.relativePath(id: "X", start: date(year: 2025, month: 1))
+                == "Workouts/2025/01/X.json")
+        #expect(WorkoutDocument.relativePath(id: "X", start: date(year: 2025, month: 9))
+                == "Workouts/2025/09/X.json")
+    }
+
+    /// December → January crosses the year, not just the month bucket.
+    @Test func crossesYearBoundary() {
+        #expect(WorkoutDocument.relativePath(id: "DEC", start: date(year: 2024, month: 12))
+                == "Workouts/2024/12/DEC.json")
+        #expect(WorkoutDocument.relativePath(id: "JAN", start: date(year: 2025, month: 1))
+                == "Workouts/2025/01/JAN.json")
+    }
+
+    /// The instance `relativePath` property and the static computation agree — the
+    /// document's own bucket is exactly what the engine writes it to.
+    @Test func instancePropertyMatchesStatic() {
+        let doc = WorkoutDocument(
+            schemaVersion: WorkoutDocument.currentSchemaVersion, id: "01WK", splitID: nil,
+            splitName: nil, start: date(year: 2024, month: 7), end: nil,
+            status: WorkoutStatus.notStarted.rawValue, createdAt: date(year: 2024, month: 7),
+            updatedAt: date(year: 2024, month: 7), logs: [], metrics: nil
+        )
+        #expect(doc.relativePath == "Workouts/2024/07/01WK.json")
+        #expect(doc.relativePath == WorkoutDocument.relativePath(id: doc.id, start: doc.start))
+    }
+
+    /// FIX-1 (rebucketing orphan) — path-computation level. `SyncEngine.save(workout:)`
+    /// needs a live iCloud container to exercise directly, so this pins the invariant it
+    /// relies on: the SAME workout id, saved after its `start` moves to a different month,
+    /// resolves to a DIFFERENT path. The old file at the previous bucket is therefore an
+    /// orphan the engine must now remove (same id lives on at the new path → plain
+    /// removal, no tombstone). If these two paths were ever equal the fix would be a
+    /// no-op; this test guarantees they diverge exactly when the month changes.
+    @Test func editingStartMonthRebucketsSameID() {
+        let id = "01WORKOUTREBUCKET00000001"
+        let marchStart = date(year: 2024, month: 3)
+        let aprilStart = date(year: 2024, month: 4)
+
+        let oldPath = WorkoutDocument.relativePath(id: id, start: marchStart)
+        let newPath = WorkoutDocument.relativePath(id: id, start: aprilStart)
+
+        #expect(oldPath != newPath)                              // the orphan-producing divergence
+        #expect(oldPath == "Workouts/2024/03/\(id).json")
+        #expect(newPath == "Workouts/2024/04/\(id).json")
+        // Same-month edits (e.g. bumping the day/hour) keep the path stable → no orphan,
+        // no removal.
+        let sameMonthLater = date(year: 2024, month: 3, day: 28, hour: 6)
+        #expect(WorkoutDocument.relativePath(id: id, start: sameMonthLater) == oldPath)
+    }
+}