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_server/src/main.rs

@@ -1,2 +1,61 @@
-// Full server implementation added in Phase 8C.
-fn main() {}
+//! Solitaire Quest sync server entry point.
+//!
+//! Reads configuration from environment variables (via `dotenvy`), initialises
+//! the SQLite database, runs migrations, then starts the Axum HTTP server.
+//!
+//! ## Required environment variables
+//!
+//! | Variable       | Description                                       |
+//! |----------------|---------------------------------------------------|
+//! | `DATABASE_URL` | SQLite connection string, e.g. `sqlite://sol.db`  |
+//! | `JWT_SECRET`   | HS256 signing secret (min 32 chars recommended)   |
+//!
+//! ## Optional
+//!
+//! | Variable      | Default | Description                   |
+//! |---------------|---------|-------------------------------|
+//! | `SERVER_PORT` | `8080`  | TCP port to listen on         |
+
+use solitaire_server::build_router;
+use sqlx::SqlitePool;
+use std::net::SocketAddr;
+
+#[tokio::main]
+async fn main() {
+    // Load .env file if present (silently ignored when absent).
+    dotenvy::dotenv().ok();
+
+    // Initialise structured logging.
+    tracing_subscriber::fmt::init();
+
+    let db_url = std::env::var("DATABASE_URL").expect("DATABASE_URL must be set");
+    let port: u16 = std::env::var("SERVER_PORT")
+        .unwrap_or_else(|_| "8080".into())
+        .parse()
+        .expect("SERVER_PORT must be a valid port number");
+
+    // Connect to SQLite and run pending migrations.
+    let pool = SqlitePool::connect(&db_url)
+        .await
+        .expect("failed to connect to database");
+
+    sqlx::migrate!("./migrations")
+        .run(&pool)
+        .await
+        .expect("database migration failed");
+
+    tracing::info!("database ready at {db_url}");
+
+    let app = build_router(pool);
+
+    let addr = SocketAddr::from(([0, 0, 0, 0], port));
+    tracing::info!("listening on {addr}");
+
+    let listener = tokio::net::TcpListener::bind(addr)
+        .await
+        .expect("failed to bind TCP listener");
+
+    axum::serve(listener, app)
+        .await
+        .expect("server error");
+}