feat(core): unlock foundations — Foundation(u8) slots, suit derived from contents

Standard Klondike behaviour: any Ace can land in any empty foundation,
and that slot then claims the suit until the pile empties. The
previous PileType::Foundation(Suit) variant pre-assigned each of the
four foundations to a fixed suit ("C / D / H / S" placeholders) and
rejected mismatched Aces — non-standard and (per the smoke-test
feedback) confusing.

Replaces the variant payload with a slot index Foundation(u8) (0..=3)
and derives the claimed suit from the bottom card via a new
Pile::claimed_suit() method. The bottom card is, by construction,
the Ace that established the claim; using it directly eliminates an
entire class of "stuck claim after undo" bugs that a separate
claimed_suit field would have introduced.

can_place_on_foundation drops its suit parameter — the rule reduces
to "empty pile accepts any Ace; non-empty pile accepts the next
rank up of the bottom card's suit." Iteration sites across
input_plugin, cursor_plugin, selection_plugin, card_plugin,
auto_complete_plugin, game_plugin, layout, and hud_plugin all swap
the four-suit list for `(0..4u8).map(PileType::Foundation)`.

next_auto_complete_move now prefers a slot whose claimed_suit matches
the candidate card before falling back to the first empty slot for
an Ace — so the same suit consistently auto-targets the same slot
across the whole game, matching player expectations.

The HUD selection label and the hint toast read claimed_suit() and
fall back to "Foundation N" / "move to foundation" only when the
slot is empty. Empty foundation pile markers no longer render the
suit-letter children — they're plain translucent rectangles, matching
empty tableau placeholders.

Save-format invalidation: GameState gains a schema_version field
(serde-default to 1 for back-compat parsing of old files), the
constant is bumped to 2, and load_game_state_from rejects mismatched
schemas. Old in-progress saves silently fall through to "fresh game
on launch" — the user accepted this loss given the mechanic change.
Stats / progress / achievements / settings live in separate files,
contain no PileType data, and are unaffected.

9 new tests pin the contract:
- Pile::claimed_suit returns None for empty / non-foundation, Some
  for non-empty foundation
- Any Ace lands in the first empty foundation; successive Aces
  distribute across slots 0..3
- Claim drops when the slot is emptied via undo
- Auto-complete picks the slot with a matching claim, not the first
  empty slot
- A v1-format game_state.json is rejected; sibling stats save/load
  is unaffected

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

solitaire_engine/src/hud_plugin.rs

@@ -1557,6 +1557,7 @@ fn update_hud(
 /// indicator stays in sync with the selection resource.
 fn update_selection_hud(
     selection: Option<Res<SelectionState>>,
+    game: Option<Res<GameStateResource>>,
     mut q: Query<&mut Text, With<HudSelection>>,
 ) {
     let Ok(mut t) = q.single_mut() else { return };
@@ -1564,7 +1565,29 @@ fn update_selection_hud(
         None => String::new(),
         Some(PileType::Waste) => "▶ Waste".to_string(),
         Some(PileType::Stock) => "▶ Stock".to_string(),
-        Some(PileType::Foundation(suit)) => {
+        Some(PileType::Foundation(slot)) => match game.as_deref() {
+            Some(g) => foundation_selection_label(*slot, &g.0),
+            // No game resource means we can't probe claimed_suit; show the
+            // slot-based placeholder so the HUD still surfaces the selection.
+            None => format!("▶ Foundation {}", slot + 1),
+        },
+        Some(PileType::Tableau(idx)) => format!("▶ Column {}", idx + 1),
+    };
+    **t = label;
+}
+
+/// Returns the HUD selection label for a foundation slot.
+///
+/// When the slot has a claimed suit (any card has landed) the announcement is
+/// "▶ {Suit} Foundation"; while the slot is empty it falls back to a
+/// "▶ Foundation N" placeholder labelled by the 1-based slot index.
+fn foundation_selection_label(slot: u8, game: &solitaire_core::game_state::GameState) -> String {
+    let claimed = game
+        .piles
+        .get(&PileType::Foundation(slot))
+        .and_then(|p| p.claimed_suit());
+    match claimed {
+        Some(suit) => {
             let s = match suit {
                 Suit::Clubs => "Clubs",
                 Suit::Diamonds => "Diamonds",
@@ -1573,9 +1596,8 @@ fn update_selection_hud(
             };
             format!("▶ {s} Foundation")
         }
-        Some(PileType::Tableau(idx)) => format!("▶ Column {}", idx + 1),
-    };
-    **t = label;
+        None => format!("▶ Foundation {}", slot + 1),
+    }
 }
 
 /// Fires `InfoToastEvent("Auto-completing...")` exactly once each time