feat: always-optimistic write pattern across all repos

All create/update/delete repo methods now write to IndexedDB optimistically
and fire mutationQueue.flush() as fire-and-forget, returning immediately
without waiting for the network. This eliminates the 8-second UX freeze
previously seen when the API was unreachable but navigator.onLine was true.

- Repos rewritten: trip, day, place, packing, todo, budget, accommodation,
  reservation, file — write methods never throw, always return optimistic data
- mutationQueue.flush() changed to iterative (one item per loop iteration)
  so mutations enqueued mid-flush (e.g. bulk check-all) are picked up
- fileRepo.toggleStar skips the IDB put when the file is not cached locally
- DayDetailPanel passes place_name into accommodationRepo.create so the
  optimistic accommodation renders the correct hotel label immediately
- Test suite updated throughout to reflect optimistic-first semantics:
  no more rollback assertions, IDB cleared in component test beforeEach hooks,
  FileManager tests switched from filesApi spy to MSW endpoint assertions

client/src/repo/reservationRepo.ts

@@ -29,75 +29,63 @@ export const reservationRepo = {
   },
 
   async create(tripId: number | string, data: Record<string, unknown>): Promise<{ reservation: Reservation }> {
-    if (!navigator.onLine) {
-      const tempId = -(Date.now())
-      const tempReservation: Reservation = {
-        ...(data as Partial<Reservation>),
-        id: tempId,
-        trip_id: Number(tripId),
-        name: (data.name as string) ?? 'New reservation',
-        type: (data.type as string) ?? 'other',
-        status: 'pending',
-        date: (data.date as string) ?? null,
-        time: null,
-        confirmation_number: null,
-        notes: null,
-        url: null,
-        created_at: new Date().toISOString(),
-      } as Reservation
-      await offlineDb.reservations.put(tempReservation)
-      await mutationQueue.enqueue({
-        id: generateUUID(),
-        tripId: Number(tripId),
-        method: 'POST',
-        url: `/trips/${tripId}/reservations`,
-        body: data,
-        resource: 'reservations',
-        tempId,
-      })
-      return { reservation: tempReservation }
-    }
-    const result = await reservationsApi.create(tripId, data)
-    offlineDb.reservations.put(result.reservation)
-    return result
+    const tempId = -(Date.now())
+    const tempReservation: Reservation = {
+      ...(data as Partial<Reservation>),
+      id: tempId,
+      trip_id: Number(tripId),
+      name: (data.name as string) ?? 'New reservation',
+      type: (data.type as string) ?? 'other',
+      status: 'pending',
+      date: (data.date as string) ?? null,
+      time: null,
+      confirmation_number: null,
+      notes: null,
+      url: null,
+      created_at: new Date().toISOString(),
+    } as Reservation
+    await offlineDb.reservations.put(tempReservation)
+    await mutationQueue.enqueue({
+      id: generateUUID(),
+      tripId: Number(tripId),
+      method: 'POST',
+      url: `/trips/${tripId}/reservations`,
+      body: data,
+      resource: 'reservations',
+      tempId,
+    })
+    mutationQueue.flush().catch(() => {})
+    return { reservation: tempReservation }
   },
 
   async update(tripId: number | string, id: number, data: Record<string, unknown>): Promise<{ reservation: Reservation }> {
-    if (!navigator.onLine) {
-      const existing = await offlineDb.reservations.get(id)
-      const optimistic: Reservation = { ...(existing ?? {} as Reservation), ...(data as Partial<Reservation>), id }
-      await offlineDb.reservations.put(optimistic)
-      await mutationQueue.enqueue({
-        id: generateUUID(),
-        tripId: Number(tripId),
-        method: 'PUT',
-        url: `/trips/${tripId}/reservations/${id}`,
-        body: data,
-        resource: 'reservations',
-      })
-      return { reservation: optimistic }
-    }
-    const result = await reservationsApi.update(tripId, id, data)
-    offlineDb.reservations.put(result.reservation)
-    return result
+    const existing = await offlineDb.reservations.get(id)
+    const optimistic: Reservation = { ...(existing ?? {} as Reservation), ...(data as Partial<Reservation>), id }
+    await offlineDb.reservations.put(optimistic)
+    await mutationQueue.enqueue({
+      id: generateUUID(),
+      tripId: Number(tripId),
+      method: 'PUT',
+      url: `/trips/${tripId}/reservations/${id}`,
+      body: data,
+      resource: 'reservations',
+    })
+    mutationQueue.flush().catch(() => {})
+    return { reservation: optimistic }
   },
 
   async delete(tripId: number | string, id: number): Promise<unknown> {
-    if (!navigator.onLine) {
-      await offlineDb.reservations.delete(id)
-      await mutationQueue.enqueue({
-        id: generateUUID(),
-        tripId: Number(tripId),
-        method: 'DELETE',
-        url: `/trips/${tripId}/reservations/${id}`,
-        body: undefined,
-        resource: 'reservations',
-        entityId: id,
-      })
-      return { success: true }
-    }
-    const result = await reservationsApi.delete(tripId, id)
-    offlineDb.reservations.delete(id)
-    return result
+    await offlineDb.reservations.delete(id)
+    await mutationQueue.enqueue({
+      id: generateUUID(),
+      tripId: Number(tripId),
+      method: 'DELETE',
+      url: `/trips/${tripId}/reservations/${id}`,
+      body: undefined,
+      resource: 'reservations',
+      entityId: id,
+    })
+    mutationQueue.flush().catch(() => {})
+    return { success: true }
   },
 }