perf: eliminate full rescans with local caches; add queue tracking, notifications, SyncView redesign

Cached indexes:
- NASManifestCache: actor-based disk cache for the NAS manifest (kisani_manifest_cache.json)
  Avoids NAS network round-trip when cache < 5 min old. Updated after every manifest download.
- LocalPhotoIndex: actor-based disk cache of phone asset metadata (kisani_local_index.json)
  Built once on first launch, then updated incrementally via PHPhotoLibraryChangeObserver.
  O(1) countSafe via in-memory dict (vs PHFetchResult batch enumeration + CoreData calls).

Fast path reconcile:
  When both caches are warm, reconcile() skips NAS connection + PHFetchResult enumeration
  entirely and returns in microseconds. Falls through to full NAS path only when stale.

AutoBackupCoordinator.onActive():
  Changed force: true → force: false so the 30-second debounce prevents expensive rescans
  on rapid app foreground/background cycles. Dashboard appears instantly from cached snapshot.

BackupQueueItem + queue tracking:
  BackupEngine publishes queueItems: [BackupQueueItem] with per-file status, progress,
  speed, error details. Queue is persisted to disk and reloaded on next launch so SyncView
  always has data to show even after restart.

NotificationService:
  Centralised local notification sender replacing the inline UNMutableNotificationContent
  blocks. Sends for: backup started, completed, failed, paused, NAS offline. Uses category
  identifiers so same-type notifications replace each other.

SyncView redesign:
  - Removed pill/chip around NAS IP — replaced with plain "Online/Offline/Checking" dot+text
  - No live NAS directory listing (was expensive NAS connection on every tab open)
  - Shows engine.queueItems grouped into Active / Failed / Completed sections
  - Per-file rows with inline progress bar + bytes/speed for uploading items, error text for failed
  - Idle state shows archive count from statusService snapshot

GalleryViewModel:
  NAS tab and All tab now use NASManifestCache as fallback when statusService.lastManifest
  is nil (offline launch). Gallery shows NAS items even when NAS is unreachable.

AppDelegate:
  Bootstraps LocalPhotoIndex.loadOrBuild() in background on launch (non-blocking).

Co-Authored-By: Kutesir <kutesir@provoc.ug>
Co-Authored-By: Sentry <sentry@provoc.ug>

Services/NASManifestCache.swift

@@ -0,0 +1,72 @@
+import Foundation
+import os.log
+
+private let log = Logger(subsystem: "com.albert.nasbackup", category: "ManifestCache")
+
+/// Persists a copy of the NAS backup manifest on-device so reconciliation can
+/// skip the NAS network round-trip when the cache is still fresh.
+///
+/// Cache is updated after every successful manifest download and after every
+/// completed backup. Stale threshold = 5 minutes. The actor serialises all
+/// reads and writes so the cache is safe to use across tasks and threads.
+actor NASManifestCache {
+    static let shared = NASManifestCache()
+
+    private var cached: CachedEntry?
+    private let diskURL: URL
+    private static let staleInterval: TimeInterval = 5 * 60
+
+    private struct CachedEntry: Codable {
+        var manifest: BackupManifest
+        var savedAt: Date
+    }
+
+    private init() {
+        let caches = FileManager.default.urls(for: .cachesDirectory, in: .userDomainMask)[0]
+        diskURL = caches.appendingPathComponent("kisani_manifest_cache.json")
+        // Load from disk immediately so the first `manifest` access is instant.
+        if let data = try? Data(contentsOf: diskURL),
+           let entry = try? JSONDecoder.kisani.decode(CachedEntry.self, from: data) {
+            cached = entry
+            log.info("ManifestCache: loaded \(entry.manifest.entries.count) entries from disk")
+        }
+    }
+
+    /// Returns the cached manifest without any I/O. Never nil after first reconcile.
+    var manifest: BackupManifest? { cached?.manifest }
+
+    /// True when the cache is absent or older than the stale threshold.
+    var isStale: Bool {
+        guard let c = cached else { return true }
+        return Date().timeIntervalSince(c.savedAt) > NASManifestCache.staleInterval
+    }
+
+    /// Persist a freshly-downloaded manifest. Call after every successful NAS download.
+    func update(_ manifest: BackupManifest) {
+        let entry = CachedEntry(manifest: manifest, savedAt: Date())
+        cached = entry
+        log.info("ManifestCache: updated — \(manifest.entries.count) entries")
+        Task.detached(priority: .utility) { [entry, url = diskURL] in
+            guard let data = try? JSONEncoder.kisani.encode(entry) else { return }
+            try? data.write(to: url, options: .atomic)
+        }
+    }
+}
+
+// MARK: — Shared encoder/decoder
+
+extension JSONEncoder {
+    static let kisani: JSONEncoder = {
+        let e = JSONEncoder()
+        e.dateEncodingStrategy = .iso8601
+        return e
+    }()
+}
+
+extension JSONDecoder {
+    static let kisani: JSONDecoder = {
+        let d = JSONDecoder()
+        d.dateDecodingStrategy = .iso8601
+        return d
+    }()
+}