Add POI category filters, delete item button, and fix itinerary persistence

- Expand POI categories from 5 to 7 (restaurant, bar, coffee, hotel, parking, attraction, entertainment)
- Add category filter chips with per-category API calls and caching
- Add delete button with confirmation dialog to Edit Item sheet
- Fix itinerary items not persisting: use LocalItineraryItem (SwiftData) as primary store with CloudKit sync as secondary, register model in schema

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

SportsTime/Features/Trip/Views/TripDetailView.swift

@@ -106,7 +106,8 @@ struct TripDetailView: View {
                 addItemAnchor: $addItemAnchor,
                 editingItem: $editingItem,
                 tripId: trip.id,
-                saveItineraryItem: saveItineraryItem
+                saveItineraryItem: saveItineraryItem,
+                deleteItineraryItem: deleteItineraryItem
             ))
             .alert("Large Trip Route", isPresented: $showMultiRouteAlert) {
                 ForEach(multiRouteChunks.indices, id: \.self) { index in
@@ -858,6 +859,9 @@ struct TripDetailView: View {
             itineraryItems[idx] = updated
         }
 
+        // Persist locally
+        saveItemLocally(updated, isUpdate: true)
+
         // Sync to CloudKit (debounced)
         await ItineraryItemService.shared.updateItem(updated)
         print("✅ [Move] Synced \(title) with day: \(day), sortOrder: \(sortOrder)")
@@ -1383,64 +1387,96 @@ struct TripDetailView: View {
         }
     }
 
-    // MARK: - Itinerary Items (CloudKit persistence)
+    // MARK: - Itinerary Items (Local-first persistence with CloudKit sync)
 
     private func loadItineraryItems() async {
         print("🔍 [ItineraryItems] Loading items for trip: \(trip.id)")
+
+        // 1. Load from local SwiftData first (instant, works offline)
+        let tripId = trip.id
+        let descriptor = FetchDescriptor<LocalItineraryItem>(
+            predicate: #Predicate { $0.tripId == tripId }
+        )
+        let localItems = (try? modelContext.fetch(descriptor))?.compactMap(\.toItem) ?? []
+        if !localItems.isEmpty {
+            print("✅ [ItineraryItems] Loaded \(localItems.count) items from local cache")
+            itineraryItems = localItems
+            extractTravelOverrides(from: localItems)
+        }
+
+        // 2. Try CloudKit for latest data (background sync)
         do {
-            let items = try await ItineraryItemService.shared.fetchItems(forTripId: trip.id)
-            print("✅ [ItineraryItems] Loaded \(items.count) items from CloudKit")
-            itineraryItems = items
+            let cloudItems = try await ItineraryItemService.shared.fetchItems(forTripId: trip.id)
+            print("✅ [ItineraryItems] Loaded \(cloudItems.count) items from CloudKit")
 
-            // Extract travel overrides (day + sortOrder) from travel-type items
-            var overrides: [String: TravelOverride] = [:]
-
-            for item in items where item.isTravel {
-                guard let travelInfo = item.travelInfo else { continue }
-                if let segIdx = travelInfo.segmentIndex,
-                   segIdx >= 0,
-                   segIdx < trip.travelSegments.count {
-                    let segment = trip.travelSegments[segIdx]
-                    if !travelInfo.matches(segment: segment) {
-                        print("⚠️ [TravelOverrides] Mismatched travel cities for segment \(segIdx); using canonical segment cities")
-                    }
-                    let travelId = stableTravelAnchorId(segment, at: segIdx)
-                    overrides[travelId] = TravelOverride(day: item.day, sortOrder: item.sortOrder)
-                    continue
-                }
-
-                // Legacy record without segment index: only accept if the city pair maps uniquely.
-                let matches = trip.travelSegments.enumerated().filter { _, segment in
-                    travelInfo.matches(segment: segment)
-                }
-
-                guard matches.count == 1, let match = matches.first else {
-                    print("⚠️ [TravelOverrides] Ignoring ambiguous legacy travel override \(travelInfo.fromCity)->\(travelInfo.toCity)")
-                    continue
-                }
-
-                let segIdx = match.offset
-                let segment = match.element
-                let travelId = stableTravelAnchorId(segment, at: segIdx)
-                overrides[travelId] = TravelOverride(day: item.day, sortOrder: item.sortOrder)
+            // Merge: use CloudKit as source of truth when available
+            if !cloudItems.isEmpty || localItems.isEmpty {
+                itineraryItems = cloudItems
+                extractTravelOverrides(from: cloudItems)
+                syncLocalCache(with: cloudItems)
             }
-
-            travelOverrides = overrides
-            print("✅ [TravelOverrides] Extracted \(overrides.count) travel overrides (day + sortOrder)")
         } catch {
-            print("❌ [ItineraryItems] Failed to load: \(error)")
+            print("⚠️ [ItineraryItems] CloudKit fetch failed (using local cache): \(error)")
         }
     }
 
+    private func extractTravelOverrides(from items: [ItineraryItem]) {
+        var overrides: [String: TravelOverride] = [:]
+
+        for item in items where item.isTravel {
+            guard let travelInfo = item.travelInfo else { continue }
+            if let segIdx = travelInfo.segmentIndex,
+               segIdx >= 0,
+               segIdx < trip.travelSegments.count {
+                let segment = trip.travelSegments[segIdx]
+                if !travelInfo.matches(segment: segment) {
+                    print("⚠️ [TravelOverrides] Mismatched travel cities for segment \(segIdx); using canonical segment cities")
+                }
+                let travelId = stableTravelAnchorId(segment, at: segIdx)
+                overrides[travelId] = TravelOverride(day: item.day, sortOrder: item.sortOrder)
+                continue
+            }
+
+            let matches = trip.travelSegments.enumerated().filter { _, segment in
+                travelInfo.matches(segment: segment)
+            }
+
+            guard matches.count == 1, let match = matches.first else {
+                print("⚠️ [TravelOverrides] Ignoring ambiguous legacy travel override \(travelInfo.fromCity)->\(travelInfo.toCity)")
+                continue
+            }
+
+            let segIdx = match.offset
+            let segment = match.element
+            let travelId = stableTravelAnchorId(segment, at: segIdx)
+            overrides[travelId] = TravelOverride(day: item.day, sortOrder: item.sortOrder)
+        }
+
+        travelOverrides = overrides
+        print("✅ [TravelOverrides] Extracted \(overrides.count) travel overrides (day + sortOrder)")
+    }
+
+    private func syncLocalCache(with items: [ItineraryItem]) {
+        let tripId = trip.id
+        let descriptor = FetchDescriptor<LocalItineraryItem>(
+            predicate: #Predicate { $0.tripId == tripId }
+        )
+        let existing = (try? modelContext.fetch(descriptor)) ?? []
+        for old in existing { modelContext.delete(old) }
+        for item in items {
+            if let local = LocalItineraryItem.from(item) {
+                modelContext.insert(local)
+            }
+        }
+        try? modelContext.save()
+    }
+
     private func saveItineraryItem(_ item: ItineraryItem) async {
-        // Check if this is an update or create
         let isUpdate = itineraryItems.contains(where: { $0.id == item.id })
         let title = item.customInfo?.title ?? "item"
         print("💾 [ItineraryItems] Saving item: '\(title)' (isUpdate: \(isUpdate))")
-        print("   - tripId: \(item.tripId)")
-        print("   - day: \(item.day), sortOrder: \(item.sortOrder)")
 
-        // Update local state immediately for responsive UI
+        // Update in-memory state immediately
         if isUpdate {
             if let index = itineraryItems.firstIndex(where: { $0.id == item.id }) {
                 itineraryItems[index] = item
@@ -1449,7 +1485,10 @@ struct TripDetailView: View {
             itineraryItems.append(item)
         }
 
-        // Persist to CloudKit
+        // Persist to local SwiftData immediately
+        saveItemLocally(item, isUpdate: isUpdate)
+
+        // Sync to CloudKit in background
         do {
             if isUpdate {
                 await ItineraryItemService.shared.updateItem(item)
@@ -1457,9 +1496,41 @@ struct TripDetailView: View {
             } else {
                 _ = try await ItineraryItemService.shared.createItem(item)
                 print("✅ [ItineraryItems] Created in CloudKit: \(title)")
+                markLocalItemSynced(item.id)
             }
         } catch {
-            print("❌ [ItineraryItems] CloudKit save failed: \(error)")
+            print("⚠️ [ItineraryItems] CloudKit save failed (saved locally): \(error)")
+        }
+    }
+
+    private func saveItemLocally(_ item: ItineraryItem, isUpdate: Bool) {
+        if isUpdate {
+            let itemId = item.id
+            let descriptor = FetchDescriptor<LocalItineraryItem>(
+                predicate: #Predicate { $0.id == itemId }
+            )
+            if let existing = try? modelContext.fetch(descriptor).first {
+                existing.day = item.day
+                existing.sortOrder = item.sortOrder
+                existing.kindData = (try? JSONEncoder().encode(item.kind)) ?? existing.kindData
+                existing.modifiedAt = item.modifiedAt
+                existing.pendingSync = true
+            }
+        } else {
+            if let local = LocalItineraryItem.from(item, pendingSync: true) {
+                modelContext.insert(local)
+            }
+        }
+        try? modelContext.save()
+    }
+
+    private func markLocalItemSynced(_ itemId: UUID) {
+        let descriptor = FetchDescriptor<LocalItineraryItem>(
+            predicate: #Predicate { $0.id == itemId }
+        )
+        if let local = try? modelContext.fetch(descriptor).first {
+            local.pendingSync = false
+            try? modelContext.save()
         }
     }
 
@@ -1467,15 +1538,25 @@ struct TripDetailView: View {
         let title = item.customInfo?.title ?? "item"
         print("🗑️ [ItineraryItems] Deleting item: '\(title)'")
 
-        // Remove from local state immediately
+        // Remove from in-memory state
         itineraryItems.removeAll { $0.id == item.id }
 
+        // Remove from local SwiftData
+        let itemId = item.id
+        let descriptor = FetchDescriptor<LocalItineraryItem>(
+            predicate: #Predicate { $0.id == itemId }
+        )
+        if let local = try? modelContext.fetch(descriptor).first {
+            modelContext.delete(local)
+            try? modelContext.save()
+        }
+
         // Delete from CloudKit
         do {
             try await ItineraryItemService.shared.deleteItem(item.id)
             print("✅ [ItineraryItems] Deleted from CloudKit")
         } catch {
-            print("❌ [ItineraryItems] CloudKit delete failed: \(error)")
+            print("⚠️ [ItineraryItems] CloudKit delete failed (removed locally): \(error)")
         }
     }
 
@@ -1580,6 +1661,7 @@ struct TripDetailView: View {
             updated.modifiedAt = Date()
             updated.kind = .travel(canonicalInfo)
             itineraryItems[existingIndex] = updated
+            saveItemLocally(updated, isUpdate: true)
             await ItineraryItemService.shared.updateItem(updated)
         } else {
             // Create new travel item
@@ -1590,8 +1672,10 @@ struct TripDetailView: View {
                 kind: .travel(canonicalInfo)
             )
             itineraryItems.append(item)
+            saveItemLocally(item, isUpdate: false)
             do {
                 _ = try await ItineraryItemService.shared.createItem(item)
+                markLocalItemSynced(item.id)
             } catch {
                 print("❌ [TravelOverrides] CloudKit save failed: \(error)")
                 return
@@ -2094,6 +2178,7 @@ private struct SheetModifiers: ViewModifier {
     @Binding var editingItem: ItineraryItem?
     let tripId: UUID
     let saveItineraryItem: (ItineraryItem) async -> Void
+    let deleteItineraryItem: (ItineraryItem) async -> Void
 
     func body(content: Content) -> some View {
         content
@@ -2119,10 +2204,14 @@ private struct SheetModifiers: ViewModifier {
                 QuickAddItemSheet(
                     tripId: tripId,
                     day: item.day,
-                    existingItem: item
-                ) { updatedItem in
-                    Task { await saveItineraryItem(updatedItem) }
-                }
+                    existingItem: item,
+                    onSave: { updatedItem in
+                        Task { await saveItineraryItem(updatedItem) }
+                    },
+                    onDelete: { deletedItem in
+                        Task { await deleteItineraryItem(deletedItem) }
+                    }
+                )
             }
     }
 }