feat(mobile): boucle sync client↔serveur — outbox push + snapshot permissions

- api/types.ts : SyncOperation, SyncResult (sémantique `applied` = INDEX documentée),
  ResourcePermission (miroir docs/api-v1.md §6, consommé tel quel par saveResourcePermission)
- api/client.ts : syncOps (POST /sync/ops), getSyncPermissions (GET /sync/permissions?after=),
  hasAuthToken() ; INVALID_RESPONSE documenté dans docs/api-v1.md §1/§4
- services/db/repositories/pendingOps.ts : listQueuedOperations(limit) (batch FIFO due)
  + scheduleRetries(ids, retryAt) qui ne modifie JAMAIS attempts (erreur transitoire,
  contrairement à markPendingOperation('failed') qui incrémente + backoff)
- features/syncOutbox.ts (nouveau) :
  * pushPendingOps : batch ≤ SYNC_BATCH_SIZE (50) → ops [0, applied) passent 'completed' ;
    op à l'index applied refusée → 'failed' (backoff, dead-letter MAX_PENDING_ATTEMPTS) ;
    ops suivantes intactes (re-soumission) ; réseau/5xx → scheduleRetries (retried) sans
    dead-letter prématurée ; applied==0 && failed → rien commité, aucun compteur touché
  * refreshPermissions : delta monotone en mémoire lastPermissionCachedAt → `after`,
    upsert saveResourcePermission ; no-op sans token
- features/syncDevice.ts : le tick useSyncDevice() enchaîne SAF walk → pushPendingOps()
  → refreshPermissions(), tous deux gardés par hasAuthToken()
- tests/syncOutbox.test.ts : 12 cas (FIFO/limit, succès complet/partiel, applied=0,
  transitoire réseau + 5xx sans incrément, dead-letter après MAX_PENDING_ATTEMPTS,
  delta snapshot croisé) — npm run test:sync
- tests/e2e.live.test.ts : smoke real backend (register → push → relecture /files/folders →
  snapshot), skip si serveur down, SORTI de npm test via npm run test:e2e
- gates : npx tsc --noEmit + npm run test → 56/56 verts (24 db + 20 api + 12 sync)

mobile/services/db/repositories/pendingOps.ts

@@ -65,6 +65,37 @@ export async function getNextQueuedOperation(): Promise<PendingOperation | null>
   return row ? toPendingOperation(row) : null;
 }
 
+// Même chose mais en batch (tri FIFO identique) — utilisé par pushPendingOps.
+export async function listQueuedOperations(limit: number): Promise<PendingOperation[]> {
+  if (limit <= 0) return [];
+  const db = await getSession();
+  const rows = await db.getAllAsync<PendingOperationRow>(
+    `SELECT ${PENDING_OPERATION_COLUMNS} FROM pending_operations
+     WHERE status = 'pending'
+       AND (next_retry_at IS NULL OR next_retry_at <= ?)
+     ORDER BY created_at ASC, id ASC
+     LIMIT ?`,
+    Date.now(),
+    limit,
+  );
+  return rows.map(toPendingOperation);
+}
+
+// Reporter des opérations sans incrémenter attempts (utilisé en cas d'erreur
+// transitoire réseau/serveur, pour éviter les dead-letters prématurées).
+export async function scheduleRetries(ids: number[], retryAt: number): Promise<void> {
+  const db = await getSession();
+  const now = Date.now();
+  for (const id of ids) {
+    await db.runAsync(
+      `UPDATE pending_operations SET next_retry_at = ?, last_error_at = ? WHERE id = ?`,
+      retryAt,
+      now,
+      id,
+    );
+  }
+}
+
 export async function markPendingOperation(
   id: number,
   status: PendingOperationStatus,