refactor(core): complete card_game::Card migration across engine + wasm

Finish the half-applied Card refactor. solitaire_core::card::Card is now an
alias for the opaque card_game::Card: suit()/rank() are methods, there is no
id or face_up field, and it is Clone+Eq+Hash but not Copy. Pile accessors
return Vec<(Card, bool)> where the bool is face-up.

Card identity is now the Card value itself (via Eq/Hash), not a numeric u32:
- CardEntity stores `card: Card` (was `card_id: u32`); lookups compare cards.
- Drag/selection collections and the touch/keyboard selection setters use
  Vec<Card>; CardFlippedEvent/CardFaceRevealedEvent/HintVisualEvent carry Card.
- replay_overlay and feedback/settle/deal animations updated accordingly.

solitaire_wasm: CardSnapshot derives its JSON id from suit+rank (matching the
desktop engine), and consumes the (Card, bool) pile tuples.

test-support: TestPileState tableau overrides now carry a per-card face-up flag
so tests can place face-down tableau cards. set_test_tableau_cards keeps its
Vec<Card> signature (defaulting to face-up); new set_test_tableau_cards_with_face
takes Vec<(Card, bool)>.

cargo test --workspace passes (engine lib 897 ok, 0 failed); cargo clippy
--workspace --all-targets -- -D warnings is clean. Save/serde format unchanged.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

solitaire_core/src/proptest_tests.rs

@@ -1,4 +1,4 @@
-use card_game::Game;
+use card_game::{Card, Game};
 use klondike::{Foundation, KlondikePile, KlondikeInstruction, SkipCards, Tableau};
 use proptest::prelude::*;
 
@@ -14,13 +14,13 @@ use crate::klondike_adapter::{
 // Shared helpers
 // ---------------------------------------------------------------------------
 
-/// Collect all card IDs across every pile in a fixed traversal order:
+/// Collect all cards across every pile in a fixed traversal order:
 /// stock → waste → foundations 1–4 → tableaux 1–7.
 ///
 /// The order is deterministic for a given game state, so two calls on
 /// equivalent states produce identical Vec outputs — the right fingerprint
 /// for undo-reversibility checks.
-fn all_card_ids(game: &GameState) -> Vec<u32> {
+fn all_cards(game: &GameState) -> Vec<Card> {
     let foundations = [
         Foundation::Foundation1,
         Foundation::Foundation2,
@@ -37,19 +37,19 @@ fn all_card_ids(game: &GameState) -> Vec<u32> {
         Tableau::Tableau7,
     ];
 
-    let mut ids: Vec<u32> = game.stock_cards().iter().map(|c| c.id).collect();
-    ids.extend(game.waste_cards().iter().map(|c| c.id));
+    let mut cards: Vec<Card> = game.stock_cards().iter().map(|(c, _)| c.clone()).collect();
+    cards.extend(game.waste_cards().iter().map(|(c, _)| c.clone()));
     for f in &foundations {
-        ids.extend(
+        cards.extend(
             game.pile(KlondikePile::Foundation(*f))
                 .iter()
-                .map(|c| c.id),
+                .map(|(c, _)| c.clone()),
         );
     }
     for t in &tableaux {
-        ids.extend(game.pile(KlondikePile::Tableau(*t)).iter().map(|c| c.id));
+        cards.extend(game.pile(KlondikePile::Tableau(*t)).iter().map(|(c, _)| c.clone()));
     }
-    ids
+    cards
 }
 
 fn draw_mode_strategy() -> impl Strategy<Value = DrawMode> {
@@ -170,13 +170,12 @@ proptest! {
         let mut game = GameState::new(seed, draw_mode);
         apply_random_actions(&mut game, &actions);
 
-        let mut ids = all_card_ids(&game);
-        prop_assert_eq!(ids.len(), 52, "card count ≠ 52 (got {})", ids.len());
-        ids.sort_unstable();
-        ids.dedup();
+        let cards = all_cards(&game);
+        prop_assert_eq!(cards.len(), 52, "card count ≠ 52 (got {})", cards.len());
+        let unique: std::collections::HashSet<Card> = cards.iter().cloned().collect();
         prop_assert_eq!(
-            ids.len(), 52,
-            "duplicate card IDs found after dedup — a card was cloned"
+            unique.len(), 52,
+            "duplicate cards found after dedup — a card was cloned"
         );
     }
 
@@ -193,8 +192,8 @@ proptest! {
         let a = GameState::new(seed, draw_mode);
         let b = GameState::new(seed, draw_mode);
         prop_assert_eq!(
-            all_card_ids(&a),
-            all_card_ids(&b),
+            all_cards(&a),
+            all_cards(&b),
             "same seed + draw_mode produced different deals",
         );
     }
@@ -218,7 +217,7 @@ proptest! {
         apply_random_actions(&mut game, &setup_actions);
 
         // Snapshot the state before the move.
-        let before_ids = all_card_ids(&game);
+        let before_ids = all_cards(&game);
         let before_move_count = game.move_count;
 
         // Apply one move.
@@ -232,7 +231,7 @@ proptest! {
             "undo must succeed immediately after a successful move",
         );
         prop_assert_eq!(
-            all_card_ids(&game),
+            all_cards(&game),
             before_ids,
             "pile layout after undo differs from the pre-move snapshot",
         );