fix: backup loops because isFilenameOnly gate disables filename fallback for mixed manifests

Root cause: ManifestIndex.isFilenameOnly is false as soon as any single entry has a
localIdentifier. All filename-only entries (orphans uploaded in prior sessions without
a saved localIdentifier) are never matched, so their assets appear pending on every
reconcile and the backup re-starts from scratch on every app open.

Fix: add unclaimedFilenames set — filenames of entries with localIdentifier: "".
Use this as a targeted fallback in countSafe / pendingIDs / BackupEngine filter:
an asset not matched by localIdentifier is still considered safe if its filename
matches an unclaimed entry. This is safe because unclaimed entries are specifically
files we know are on NAS but whose identity we can only track by name.

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

Core/Models/BackupManifest.swift

@@ -7,31 +7,50 @@ import Photos
 // Sendable: all stored properties are value types — safe to pass across task boundaries.
 struct ManifestIndex: Sendable {
     let localIdentifiers: Set<String>    // PHAsset.localIdentifier (primary key)
-    let lowercasedFilenames: Set<String> // filename fallback for legacy/bootstrap entries
+    let lowercasedFilenames: Set<String> // all filenames — used for pure bootstrap mode
+    let unclaimedFilenames: Set<String>  // filenames of entries with no localIdentifier
+                                         // (orphans / pre-ID backups) — filename fallback
     let totalCount: Int                  // non-hidden file count for NAS Archive stat
 
+    /// True only when every entry lacks a localIdentifier (pure bootstrap from NAS listing).
     var isFilenameOnly: Bool { localIdentifiers.isEmpty }
 
     func matches(localIdentifier id: String) -> Bool {
         !id.isEmpty && localIdentifiers.contains(id)
     }
 
+    /// Full filename match — only used in pure bootstrap mode.
     func matches(filename: String) -> Bool {
         lowercasedFilenames.contains(filename.lowercased())
     }
 
+    /// Filename match against orphan entries only.
+    /// Use as fallback when localIdentifier matching fails: if a NAS file was uploaded
+    /// in a session where the localIdentifier wasn't saved (interrupted / pre-ID backup),
+    /// matching by filename prevents re-uploading it.
+    func matchesUnclaimed(filename: String) -> Bool {
+        unclaimedFilenames.contains(filename.lowercased())
+    }
+
     // Build from decoded manifest — manifest released by caller after this returns
     init(manifest: BackupManifest) {
-        var ids   = Set<String>(minimumCapacity: manifest.entries.count)
-        var names = Set<String>(minimumCapacity: manifest.entries.count)
+        var ids       = Set<String>(minimumCapacity: manifest.entries.count)
+        var names     = Set<String>(minimumCapacity: manifest.entries.count)
+        var unclaimed = Set<String>()
         var count = 0
         for entry in manifest.entries {
             if !entry.filename.hasPrefix(".") { count += 1 }
-            if !entry.localIdentifier.isEmpty { ids.insert(entry.localIdentifier) }
-            names.insert(entry.filename.lowercased())
+            let lower = entry.filename.lowercased()
+            names.insert(lower)
+            if !entry.localIdentifier.isEmpty {
+                ids.insert(entry.localIdentifier)
+            } else {
+                unclaimed.insert(lower)
+            }
         }
         self.localIdentifiers   = ids
         self.lowercasedFilenames = names
+        self.unclaimedFilenames  = unclaimed
         self.totalCount = count
     }
 
@@ -45,6 +64,7 @@ struct ManifestIndex: Sendable {
         }
         self.localIdentifiers   = []
         self.lowercasedFilenames = names
+        self.unclaimedFilenames  = names  // all filename-only in bootstrap mode
         self.totalCount = count
     }
 }