feat(core): add klondike v0.2.0 dep and KlondikeAdapter (integration steps 1, 3, 4)

Step 1 — Cargo & registry:
- Add .cargo/config.toml with Quaternions sparse registry
  (https://git.aleshym.co/api/packages/Quaternions/cargo/)
- Add klondike = "0.2.0" to workspace deps (+ card_game v0.3.0,
  arrayvec v0.7.6 as transitives via the Quaternions registry)
- Add klondike as a solitaire_core dep

Step 3 — KlondikeConfig / MoveFromFoundationConfig:
- KlondikeAdapter::new(draw_mode, take_from_foundation) builds a
  KlondikeConfig with the correct DrawStockConfig and
  MoveFromFoundationConfig (Allowed/Disallowed); exposes it via
  klondike_config() for future solver and pile-mapping steps

Step 4 — Scoring via ScoringConfig:
- GameState.adapter (serde(skip)) owns the authoritative KlondikeConfig
  with ScoringConfig::DEFAULT (WXP values)
- score_for_move/flip/undo/recycle replace direct scoring.rs calls;
  scoring.rs retained for reference and future deletion
- score_for_recycle implements the WXP free-recycle allowance rule
  that ScoringConfig::recycle cannot express (flat delta)
- PartialEq/Eq for KlondikeAdapter compare draw_stock and
  move_from_foundation only (scoring is always DEFAULT)

All 192 solitaire_core tests pass; clippy -D warnings clean.

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

solitaire_core/src/klondike_adapter.rs

@@ -0,0 +1,139 @@
+//! Adapter bridging `solitaire_core` types to the upstream `klondike` crate.
+//!
+//! # Current scope (integration steps 1–4)
+//!
+//! [`KlondikeAdapter`] owns the authoritative [`KlondikeConfig`] and exposes
+//! scoring helpers backed by [`ScoringConfig::DEFAULT`] (Windows XP Standard
+//! values).  [`GameState`] delegates scoring here so that klondike remains the
+//! single source of truth for scoring constants.
+//!
+//! # Not yet implemented
+//!
+//! - Live [`klondike::Klondike`] shadow state (requires pile-mapping, step 2).
+//! - Move validation via klondike's rule engine (step 2).
+//! - DFS solver via [`klondike::KlondikeState`] (step 6).
+
+use klondike::{DrawStockConfig, KlondikeConfig, MoveFromFoundationConfig, ScoringConfig};
+
+use crate::game_state::DrawMode;
+use crate::pile::PileType;
+
+/// Bridges `solitaire_core` game config and scoring to the upstream `klondike` crate.
+///
+/// Holds a [`KlondikeConfig`] reflecting the current game settings and exposes
+/// scoring helpers that read from [`ScoringConfig::DEFAULT`] (WXP values).
+/// [`GameState`] uses this instead of calling `scoring.rs` functions directly.
+#[derive(Clone, Debug)]
+pub struct KlondikeAdapter {
+    config: KlondikeConfig,
+}
+
+impl PartialEq for KlondikeAdapter {
+    fn eq(&self, other: &Self) -> bool {
+        self.config.draw_stock == other.config.draw_stock
+            && self.config.move_from_foundation == other.config.move_from_foundation
+    }
+}
+impl Eq for KlondikeAdapter {}
+
+impl Default for KlondikeAdapter {
+    /// Returns an adapter with Draw-1 and `take_from_foundation = true`,
+    /// matching `GameState`'s own defaults.  Used by `#[serde(skip)]`
+    /// field initialisation on deserialisation.
+    fn default() -> Self {
+        Self::new(DrawMode::DrawOne, true)
+    }
+}
+
+impl KlondikeAdapter {
+    /// Create an adapter from the game's draw mode and foundation house-rule setting.
+    ///
+    /// `take_from_foundation = true` maps to [`MoveFromFoundationConfig::Allowed`];
+    /// `false` maps to [`MoveFromFoundationConfig::Disallowed`].
+    pub fn new(draw_mode: DrawMode, take_from_foundation: bool) -> Self {
+        let config = KlondikeConfig {
+            draw_stock: match draw_mode {
+                DrawMode::DrawOne => DrawStockConfig::DrawOne,
+                DrawMode::DrawThree => DrawStockConfig::DrawThree,
+            },
+            move_from_foundation: if take_from_foundation {
+                MoveFromFoundationConfig::Allowed
+            } else {
+                MoveFromFoundationConfig::Disallowed
+            },
+            scoring: ScoringConfig::DEFAULT,
+        };
+        Self { config }
+    }
+
+    /// Returns a reference to the underlying [`KlondikeConfig`].
+    ///
+    /// Used by the solver and pile-mapping code added in later integration steps.
+    pub fn klondike_config(&self) -> &KlondikeConfig {
+        &self.config
+    }
+
+    /// Update the foundation house-rule flag, keeping [`KlondikeConfig`] in sync.
+    pub fn set_take_from_foundation(&mut self, allowed: bool) {
+        self.config.move_from_foundation = if allowed {
+            MoveFromFoundationConfig::Allowed
+        } else {
+            MoveFromFoundationConfig::Disallowed
+        };
+    }
+
+    // ── Scoring helpers ───────────────────────────────────────────────────
+
+    /// Score delta for a card move.
+    ///
+    /// Reads from [`ScoringConfig`] (WXP Standard values):
+    /// - Any pile → Foundation: +10
+    /// - Waste → Tableau: +5
+    /// - Foundation → Tableau: −15
+    /// - All other moves: 0
+    pub fn score_for_move(&self, from: &PileType, to: &PileType) -> i32 {
+        let sc = &self.config.scoring;
+        match (from, to) {
+            (_, PileType::Foundation(_)) => sc.move_to_foundation,
+            (PileType::Waste, PileType::Tableau(_)) => sc.move_to_tableau,
+            (PileType::Foundation(_), PileType::Tableau(_)) => sc.move_from_foundation,
+            _ => 0,
+        }
+    }
+
+    /// Score delta for exposing a face-down tableau card: +5.
+    pub fn score_for_flip(&self) -> i32 {
+        self.config.scoring.flip_up_bonus
+    }
+
+    /// Score delta for undo: −15.
+    ///
+    /// [`card_game::Session`] handles this via `SessionConfig::undo_penalty`
+    /// (default −15). We mirror the constant here so `GameState` can apply it
+    /// in its snapshot-based undo path without owning a `Session`.
+    pub const fn score_for_undo() -> i32 {
+        -15
+    }
+
+    /// Score delta for recycling waste → stock.
+    ///
+    /// [`ScoringConfig::recycle`] is a flat delta (default 0 = always free).
+    /// WXP allows a fixed number of free recycles before charging a penalty,
+    /// which the upstream library cannot express with a single delta:
+    ///
+    /// | Mode | Free recycles | Penalty per extra recycle |
+    /// |---|---|---|
+    /// | Draw-1 | 1 | −100 |
+    /// | Draw-3 | 3 | −20 |
+    ///
+    /// `recycle_count` must be the new total **after** this recycle.
+    pub fn score_for_recycle(recycle_count: u32, is_draw_three: bool) -> i32 {
+        if is_draw_three {
+            if recycle_count > 3 { -20 } else { 0 }
+        } else if recycle_count > 1 {
+            -100
+        } else {
+            0
+        }
+    }
+}