fix(multi): resolve 16 bugs from comprehensive rules and code review

Core (solitaire_core):
- fix(core): auto-complete now requires waste empty to prevent deadlock
- fix(core): reject multi-card moves from waste pile (Klondike rule)
- fix(core): reject foundation-to-foundation moves (score farming exploit)
- fix(core): undo restores score from snapshot baseline, not live score
- feat(scoring): add +5 flip bonus when face-down tableau card is exposed
- feat(scoring): add recycle penalty (Draw-1: -100/pass, Draw-3: -20/pass)

Engine (solitaire_engine):
- fix(engine): remove TokioRuntimeResource::default() panic; degrade gracefully
- fix(engine): add ModalScrim guard to handle_new_game spawn site
- fix(engine): add ModalScrim guard to spawn_restore_prompt spawn site
- fix(engine): add ModalScrim guard to check_no_moves spawn site

Server / Web (solitaire_server):
- fix(web): correct draw_mode casing in replay submission (DrawOne/DrawThree)
- fix(web): correct mode casing in replay submission (Classic) for leaderboard
- fix(web): trim recorded_at to YYYY-MM-DD for NaiveDate deserialization
- fix(server): move /avatars route outside auth middleware (was always 401)

Data / Sync (solitaire_data, solitaire_sync):
- fix(data): namespace Android token file under APP_DIR_NAME with migration
- fix(data): Android token store now multi-user (HashMap); no silent overwrite
- fix(sync): draw_one_wins + draw_three_wins invariant preserved after merge

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

solitaire_core/src/scoring.rs

@@ -5,7 +5,11 @@ use crate::pile::PileType;
 /// Windows XP Standard scoring:
 /// - +10 for any card reaching a foundation pile
 /// - +5 for a waste → tableau move
+/// - -15 for a foundation → tableau (take-from-foundation) move
 /// - 0 for all other moves
+///
+/// Note: the +5 flip bonus for exposing a face-down tableau card is applied
+/// separately in `game_state::move_cards` because it depends on post-move state.
 pub fn score_move(from: &PileType, to: &PileType) -> i32 {
     match to {
         PileType::Foundation(_) => 10,
@@ -23,6 +27,21 @@ pub fn score_undo() -> i32 {
     -15
 }
 
+/// Score bonus awarded when a face-down tableau card is flipped face-up: +5.
+pub fn score_flip() -> i32 {
+    5
+}
+
+/// Score penalty for recycling the waste pile back to stock.
+///
+/// Windows standard: the first N recycles are free (N=1 for Draw-1, N=3 for Draw-3).
+/// Subsequent recycles cost -100 (Draw-1) or -20 (Draw-3).
+/// `recycle_count` is the new total count **after** this recycle.
+pub fn score_recycle(recycle_count: u32, is_draw_three: bool) -> i32 {
+    let (free, penalty) = if is_draw_three { (3_u32, -20_i32) } else { (1_u32, -100_i32) };
+    if recycle_count > free { penalty } else { 0 }
+}
+
 /// Time bonus added to the score on a win: `700_000 / elapsed_seconds`.
 /// Returns 0 when `elapsed_seconds` is 0 to avoid division by zero.
 pub fn compute_time_bonus(elapsed_seconds: u64) -> i32 {
@@ -93,4 +112,29 @@ mod tests {
         let bonus = compute_time_bonus(1);
         assert!(bonus >= 0, "time bonus must be non-negative after u64→i32 cast");
     }
+
+    #[test]
+    fn flip_bonus_is_five() {
+        assert_eq!(score_flip(), 5);
+    }
+
+    #[test]
+    fn recycle_draw1_first_pass_free() {
+        assert_eq!(score_recycle(1, false), 0);
+    }
+
+    #[test]
+    fn recycle_draw1_second_pass_penalised() {
+        assert_eq!(score_recycle(2, false), -100);
+    }
+
+    #[test]
+    fn recycle_draw3_third_pass_free() {
+        assert_eq!(score_recycle(3, true), 0);
+    }
+
+    #[test]
+    fn recycle_draw3_fourth_pass_penalised() {
+        assert_eq!(score_recycle(4, true), -20);
+    }
 }