feat(workspace): full server + sync implementation, all tests green

- solitaire_server: Axum auth, sync push/pull, leaderboard, daily
  challenge, account deletion, JWT middleware, rate limiting via
  tower_governor, SQLite migrations, health endpoint
- solitaire_server: expose build_test_router (no rate limiting) so
  integration tests work without a peer IP in oneshot requests
- solitaire_sync: SyncPayload, merge logic, shared API types
- solitaire_data: SyncProvider trait, LocalOnlyProvider,
  SolitaireServerClient, auth_tokens keyring integration, blanket
  Box<dyn SyncProvider> impl
- solitaire_data/settings: derive Default on SyncBackend (clippy fix)
- .sqlx/: offline query cache so server compiles without a live DB
- sqlx: removed non-existent "offline" feature flag
- keyring v2: fixed Entry::new() returning Result<Entry>
- sqlx 0.8: all SQLite TEXT columns wrapped in Option<T>
- Integration tests: max_connections(1) on in-memory pool so all
  connections share the same schema

All 191 tests pass; cargo clippy -D warnings clean.

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

solitaire_sync/src/achievements.rs

@@ -0,0 +1,48 @@
+//! Shared `AchievementRecord` definition — used by both the game client and
+//! the sync server.
+
+use chrono::{DateTime, Utc};
+use serde::{Deserialize, Serialize};
+
+/// One player's unlock state for a single achievement.
+///
+/// The achievement *definition* (name, description, condition fn) lives in
+/// `solitaire_core`. This record only tracks runtime unlock state and is
+/// what gets persisted and synced.
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub struct AchievementRecord {
+    /// Matches the `id` field of the corresponding `AchievementDef` in
+    /// `solitaire_core`.
+    pub id: String,
+    /// Whether the achievement has been unlocked.
+    pub unlocked: bool,
+    /// The UTC timestamp at which the achievement was first unlocked.
+    /// `None` when not yet unlocked.
+    pub unlock_date: Option<DateTime<Utc>>,
+    /// Whether the unlock reward (XP, cosmetic, etc.) has been granted.
+    pub reward_granted: bool,
+}
+
+impl AchievementRecord {
+    /// Construct an initial record for an achievement that is not yet unlocked.
+    pub fn locked(id: impl Into<String>) -> Self {
+        Self {
+            id: id.into(),
+            unlocked: false,
+            unlock_date: None,
+            reward_granted: false,
+        }
+    }
+
+    /// Mark this record unlocked at the given timestamp.
+    ///
+    /// No-op if already unlocked — preserves the earliest `unlock_date` so
+    /// that merging two unlock records always keeps the older timestamp.
+    pub fn unlock(&mut self, at: DateTime<Utc>) {
+        if self.unlocked {
+            return;
+        }
+        self.unlocked = true;
+        self.unlock_date = Some(at);
+    }
+}