M6.4: Card-grid steps + hybrid origin + clade-restricted backgrounds

Per GODOT_PORTING_GUIDE.md §12, the four "easy" card-grid steps land
together (Species / Calling / Subclass / History), plus three real
features that emerged during testing: cross-step validation gating,
hybrid origin, and clade-restricted background availability.

New step files (Scenes/Steps/):
  StepSpecies.cs    — cards filtered by clade; for hybrids shows two
                      stacked grids (Sire / Dam).
  StepClass.cs      — all classes; class change clears chosen skills
                      and the previously-selected subclass.
  StepSubclass.cs   — subclasses filtered by ClassDef.SubclassIds.
  StepBackground.cs — backgrounds filtered by hybrid + clade rules
                      (see below).

UI/WizardValidation.cs (new):
  Static per-step validators against CharacterDraft. Replaces the
  per-instance Validate() route on the wizard side — Wizard now
  computes the lock state for every step in the flow, not just the
  current one. Mirrors app.jsx's firstIncomplete rule exactly.

  Bug it fixes: previously the wizard checked only the current step's
  validity, so picking a clade let you skip directly to Abilities
  without picking species/calling/etc.

UI/CharacterDraft.cs:
  Phase 6.5 hybrid fields — IsHybrid, SireCladeId, SireSpeciesId,
  DamCladeId, DamSpeciesId, DominantParent. EffectiveCladeId /
  EffectiveSpeciesId resolve to the dominant parent's lineage when
  hybrid; downstream steps don't need to care which path. Helpers
  HasClade(id) and HasAnyCladeOfKind(kind) feed the background
  availability rules.

StepClade.cs:
  Hybrid toggle splits the picker into Sire + Dam grids with a
  Dominant Lineage radio. Validation refuses same-clade Sire+Dam.
  Switched to build-once + mutate-in-place: cards are created once
  during Build(), Refresh just updates Modulate per selection state.
  Tearing down + rebuilding inside the click callback caused
  duplicates because Free() defers when the freed node is mid-signal.

StepBackground.cs:
  Availability rules table — predicates per restricted background id.
  Hybrid-only: passer, hybrid_underground, former_chattel.
  Clade-restricted: warren_runner (Leporidae), pack_raised (Canidae),
  herd_city_born (any prey clade).
  Hybrids match if either parent satisfies the rule.

Other steps (Species/Class/Subclass/Background):
  Refresh dispatched via Callable.From(Refresh).CallDeferred() so the
  rebuild runs after the click handler completes — same Free()-during-
  signal bug as StepClade hit, fixed via deferral instead of mutate-
  in-place because the card lists are dynamic (clade- / class- /
  hybrid-flag-dependent).

Wizard.cs:
  - RebuildStepperStates uses WizardValidation.FirstIncomplete to lock
    every step past the first unsatisfied one.
  - OnStepperClicked checks every step in [0..target-1].
  - UpdateChrome's banner uses WizardValidation for the active step.
  - Scroll preservation moved here (snapshot before step.Refresh
    fires, restore in _Process); StepStats's local copy removed.

Wizard.tscn:
  Scroll node marked unique_name_in_owner so Wizard can grab it.
  PopoverLayer's TraitChip is reused throughout the new step cards.

Aside.cs:
  Hybrid-aware summary — shows "Sire (dominant)" / "Dam" lineage rows
  when IsHybrid; otherwise the existing Clade / Species rows.

Verified end-to-end:
  - Walk Clade → Species → Calling → Subclass → History → Abilities
  - Stepper locks every step past first unsatisfied
  - Hybrid toggle works both directions, dominant changes lineage
  - Hybrid-only and clade-restricted backgrounds appear / disappear
    based on lineage
  - Scroll position preserved across selections
  - Drag-drop still works on Abilities

Closes M6.4. Per guide §12, next is M6.5 — StepSkills (class-driven
choice list with TraitChip per skill).

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

Theriapolis.Godot/Scenes/Aside.cs

@@ -40,13 +40,35 @@ public partial class Aside : MarginContainer
         foreach (var c in _content.GetChildren()) c.QueueFree();
 
         _content.AddChild(new Label { Text = "SUMMARY" });
-        AddBlock("Clade",      CodexContent.Clade(_draft.CladeId)?.Name);
-        AddBlock("Species",    CodexContent.SpeciesById(_draft.SpeciesId)?.Name);
+
+        if (_draft.IsHybrid)
+        {
+            AddBlock("Origin", "Hybrid");
+            AddBlock(_draft.DominantParent == "sire" ? "Sire (dominant)" : "Sire",
+                FormatLineage(_draft.SireCladeId, _draft.SireSpeciesId));
+            AddBlock(_draft.DominantParent == "dam" ? "Dam (dominant)" : "Dam",
+                FormatLineage(_draft.DamCladeId, _draft.DamSpeciesId));
+        }
+        else
+        {
+            AddBlock("Clade",   CodexContent.Clade(_draft.CladeId)?.Name);
+            AddBlock("Species", CodexContent.SpeciesById(_draft.SpeciesId)?.Name);
+        }
+
         AddBlock("Calling",    CodexContent.Class(_draft.ClassId)?.Name);
         AddBlock("Background", CodexContent.Background(_draft.BackgroundId)?.Name);
         AddBlock("Name",       string.IsNullOrEmpty(_draft.CharacterName) ? null : _draft.CharacterName);
     }
 
+    private static string? FormatLineage(string cladeId, string speciesId)
+    {
+        var clade = CodexContent.Clade(cladeId);
+        var species = CodexContent.SpeciesById(speciesId);
+        if (clade is null && species is null) return null;
+        if (species is not null) return $"{species.Name} ({clade?.Name ?? cladeId})";
+        return clade?.Name;
+    }
+
     private void AddBlock(string label, string? value)
     {
         var v = new VBoxContainer();