refactor: migrate PileType → KlondikePile across core/wasm/engine

- Replace PileType with typed KlondikePile (Foundation/Tableau variants)
  throughout solitaire_core, solitaire_wasm, and solitaire_engine;
  ReplayMove now uses SavedKlondikePile for serialisation stability
- Split replay_overlay.rs into replay_overlay/ module (mod, format,
  input, update, tests) for maintainability
- Add klondike dep to solitaire_engine and solitaire_data Cargo.toml
- Add TestPileState infrastructure to game_state.rs for engine unit tests
- Rebuild solitaire_wasm pkg (js + wasm artefacts updated)

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

solitaire_engine/src/pending_hint.rs

@@ -27,7 +27,7 @@
 use bevy::prelude::*;
 use bevy::tasks::{AsyncComputeTaskPool, Task, futures_lite::future};
 use solitaire_core::game_state::GameState;
-use solitaire_core::pile::PileType;
+use klondike::KlondikePile;
 use solitaire_core::solver::{SolverConfig, SolverResult, try_solve_from_state};
 
 use crate::card_plugin::CardEntity;
@@ -101,7 +101,7 @@ struct HintTask {
 enum HintTaskOutput {
     /// Solver verdict was `Winnable`; here is the first move on the
     /// solution path.
-    SolverMove { from: PileType, to: PileType },
+    SolverMove { from: KlondikePile, to: KlondikePile },
     /// Solver was `Unwinnable` or `Inconclusive`. The poll system
     /// runs the legacy heuristic against the live `GameState` so the
     /// H key always produces feedback while any legal move exists.
@@ -183,6 +183,7 @@ mod tests {
     use super::*;
     use crate::events::HintVisualEvent;
     use crate::input_plugin::HintSolverConfig;
+    use klondike::{Foundation, Tableau};
     use solitaire_core::card::{Card, Rank, Suit};
     use solitaire_core::game_state::{DrawMode, GameState};
 
@@ -214,22 +215,27 @@ mod tests {
     /// tableau columns 0..3, stock and waste empty.
     fn near_finished_state() -> GameState {
         let mut game = GameState::new(1, DrawMode::DrawOne);
-        for slot in 0..4_u8 {
-            game.piles
-                .get_mut(&PileType::Foundation(slot))
-                .unwrap()
-                .cards
-                .clear();
+        game.set_test_stock_cards(Vec::new());
+        game.set_test_waste_cards(Vec::new());
+        for foundation in [
+            Foundation::Foundation1,
+            Foundation::Foundation2,
+            Foundation::Foundation3,
+            Foundation::Foundation4,
+        ] {
+            game.set_test_foundation_cards(foundation, Vec::new());
         }
-        for i in 0..7_usize {
-            game.piles
-                .get_mut(&PileType::Tableau(i))
-                .unwrap()
-                .cards
-                .clear();
+        for tableau in [
+            Tableau::Tableau1,
+            Tableau::Tableau2,
+            Tableau::Tableau3,
+            Tableau::Tableau4,
+            Tableau::Tableau5,
+            Tableau::Tableau6,
+            Tableau::Tableau7,
+        ] {
+            game.set_test_tableau_cards(tableau, Vec::new());
         }
-        game.piles.get_mut(&PileType::Stock).unwrap().cards.clear();
-        game.piles.get_mut(&PileType::Waste).unwrap().cards.clear();
         let suits = [Suit::Clubs, Suit::Diamonds, Suit::Hearts, Suit::Spades];
         let ranks_below_king = [
             Rank::Ace,
@@ -245,31 +251,44 @@ mod tests {
             Rank::Jack,
             Rank::Queen,
         ];
-        for (slot, suit) in suits.iter().enumerate() {
-            let pile = game
-                .piles
-                .get_mut(&PileType::Foundation(slot as u8))
-                .unwrap();
+        for (foundation, suit) in [
+            Foundation::Foundation1,
+            Foundation::Foundation2,
+            Foundation::Foundation3,
+            Foundation::Foundation4,
+        ]
+        .into_iter()
+        .zip(suits.iter())
+        {
+            let mut cards = Vec::new();
             for (i, rank) in ranks_below_king.iter().enumerate() {
-                pile.cards.push(Card {
-                    id: (slot as u32) * 13 + i as u32,
+                cards.push(Card {
+                    id: (foundation as u32) * 13 + i as u32,
                     suit: *suit,
                     rank: *rank,
                     face_up: true,
                 });
             }
+            game.set_test_foundation_cards(foundation, cards);
         }
-        for (col, suit) in suits.iter().enumerate() {
-            game.piles
-                .get_mut(&PileType::Tableau(col))
-                .unwrap()
-                .cards
-                .push(Card {
-                    id: 100 + col as u32,
+        for (tableau, suit) in [
+            Tableau::Tableau1,
+            Tableau::Tableau2,
+            Tableau::Tableau3,
+            Tableau::Tableau4,
+        ]
+        .into_iter()
+        .zip(suits.iter())
+        {
+            game.set_test_tableau_cards(
+                tableau,
+                vec![Card {
+                    id: 100 + tableau as u32,
                     suit: *suit,
                     rank: Rank::King,
                     face_up: true,
-                });
+                }],
+            );
         }
         game
     }
@@ -309,7 +328,7 @@ mod tests {
             "exactly one HintVisualEvent must fire when the solver returns Winnable",
         );
         assert!(
-            matches!(collected[0].dest_pile, PileType::Foundation(_)),
+            matches!(collected[0].dest_pile, KlondikePile::Foundation(_)),
             "solver hint destination must be a foundation slot; got {:?}",
             collected[0].dest_pile,
         );