feat: enforce schedule rules in the background via DeviceActivity windows

Schedule (time-window) rules had no background enforcement: RuleScheduler.sync()
skipped them, so their shields were applied only by RuleEnforcer.refresh() — the
launch + 30s foreground loop. A window that began while the app was closed didn't
engage until the user reopened the app, which is why scheduled blocks could land
late or unevenly.

RuleScheduler now registers a repeating DeviceActivitySchedule per enabled
schedule rule's window (sched-<uuid>, plus sched2-<uuid> for windows that cross
midnight, since DeviceActivity can't express an interval whose end precedes its
start). The monitor extension routes these to a new ScheduleEnforcement.reconcile(),
which recomputes the rule's live schedule state from its snapshot
(RuleSchedule.isActive, honouring days, pause and the midnight-crossing rule) and
applies or clears the shield to match — the same logic RuleEnforcer.refresh runs
in the foreground, kept as the reconciliation safety net because interval callbacks
are known to fire late or not at all.

- RuleSnapshot gains startMinutes/endMinutes, with a tolerant decoder so snapshots
  written before these fields still load instead of failing the whole batch and
  blinding the extensions until the app reopens.
- Window activities are fingerprinted on their interval alone, so changing days,
  mode or apps no longer needlessly restarts monitoring.

On-device verification of the background transition is still pending (the simulator
does not deliver DeviceActivity callbacks); covered by new unit tests across the
scheduler, the snapshot codec and the new enforcement reactions.

Shared/MonitoringPlan.swift

@@ -12,6 +12,8 @@ enum MonitoringPlan {
     private static let dailyPrefix = "rule-"
     private static let sessionPrefix = "open-session-"
     private static let minutePrefix = "minutes-"
+    private static let scheduleWindowPrefix = "sched-"
+    private static let scheduleWindowLatePrefix = "sched2-"
 
     /// Wall-clock length of one granted open. 15 minutes is DeviceActivity's
     /// minimum schedule interval, so an "open" lasts at most this long before
@@ -38,6 +40,28 @@ enum MonitoringPlan {
         return UUID(uuidString: String(name.dropFirst(sessionPrefix.count)))
     }
 
+    /// The primary window activity for a schedule rule. A second
+    /// (`scheduleWindowLateName`) covers the post-midnight half of a window
+    /// that crosses midnight, since DeviceActivity can't express an interval
+    /// whose end is earlier than its start.
+    static func scheduleWindowName(for ruleID: UUID) -> String {
+        scheduleWindowPrefix + ruleID.uuidString
+    }
+
+    static func scheduleWindowLateName(for ruleID: UUID) -> String {
+        scheduleWindowLatePrefix + ruleID.uuidString
+    }
+
+    static func ruleID(fromScheduleWindowName name: String) -> UUID? {
+        if name.hasPrefix(scheduleWindowLatePrefix) {
+            return UUID(uuidString: String(name.dropFirst(scheduleWindowLatePrefix.count)))
+        }
+        if name.hasPrefix(scheduleWindowPrefix) {
+            return UUID(uuidString: String(name.dropFirst(scheduleWindowPrefix.count)))
+        }
+        return nil
+    }
+
     static func minuteEventName(for minutes: Int) -> String {
         minutePrefix + String(minutes)
     }