First pass at full refactor to 2.0 design

Restructures the game around the cyclical run loop from Game Design Doc V2:
5 waves = a cycle, 3 cycles = a phase, each phase ends in a boss.

- New TD.Gameplay.Waves: WaveGroup / PhaseDefinition / RunDefinition author the
  run as draggable weighted pools; RunState owns phase/cycle position, the drawn
  wave slots, and the per-slot enemy buff sets. WaveManager's flat wave array is
  gone -- it now only runs the encounter RunState points at.
- New TD.Gameplay.EnemyUpgrades: the post-wave enemy-buff vote, with public
  live-replicated ballots so the HUD can show who voted for what.
- Inter-wave flow is now strictly sequential: draft -> vote -> build, each stage
  ending early once every player has acted.
- Enemy abilities inverted from per-instance random rolls to deterministic,
  stacking per-wave-slot sets. Six cards ship: Split (reworked), Flight, Blink,
  No Bounty, Gold Theft, Double Up.
- Tower upgrades are a two-step tree: a draft pick unlocks a node, gold converts
  an already-placed tower in place.
- Boss encounters flag their enemies and drive a boss HP bar.
- Player cap reduced to 3 via MatchRules.MaxPlayers.
- GoldConfig is now keyed by global encounter number rather than wave index.

Compiles clean; NOT yet verified in-engine. Editor wiring still required --
see Docs/2.0_Setup_Checklist.md.

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

Assets/_Project/Scripts/Gameplay/EnemyAbilities/EnemyAbilityPool.cs

@@ -13,8 +13,12 @@ namespace TD.Gameplay.EnemyAbilities
     /// </summary>
     /// <remarks>
     /// Plain MonoBehaviour: identical on every peer (same assets), so there is nothing to sync.
-    /// Only the server calls <see cref="RollRandom"/> (at enemy spawn time, in
-    /// <c>WaveManager.SpawnEnemy</c>).
+    ///
+    /// <para><b>Lookup only — no rolling.</b> This pool used to draw a random ability per spawned
+    /// enemy against a "no ability" weight. Under the 2.0 design abilities are chosen by the
+    /// players' post-wave vote and apply to every enemy in the wave, so the draw moved to
+    /// <c>WaveVote</c> (over cards, not abilities) and this is purely the kind→asset table
+    /// <c>WaveManager</c> resolves against at spawn time.</para>
     /// </remarks>
     public class EnemyAbilityPool : MonoBehaviour
     {
@@ -25,11 +29,6 @@ namespace TD.Gameplay.EnemyAbilities
                  "its slot.")]
         [SerializeField] private EnemyAbilityDefinition[] abilities;
 
-        [Tooltip("Relative weight of an enemy rolling no ability at all, vs. the combined " +
-                 "weight of every entry in 'abilities'. Higher = abilities are rarer.")]
-        [Min(0f)]
-        [SerializeField] private float noAbilityWeight = 100f;
-
         // Fixed-size, enum-indexed lookup built once in Awake. Sized to the enum's entry count,
         // not authored count, so an out-of-range Kind is a compile-time impossibility rather
         // than a bounds check we'd otherwise need on every Get().
@@ -68,35 +67,5 @@ namespace TD.Gameplay.EnemyAbilities
             int i = (int)kind;
             return (byKind != null && i >= 0 && i < byKind.Length) ? byKind[i] : null;
         }
-
-        /// <summary>
-        /// Server-only: weighted random draw across every authored ability plus the
-        /// no-ability bucket. Returns null when "no ability" is drawn, or when the pool has
-        /// nothing authored.
-        /// </summary>
-        public EnemyAbilityDefinition RollRandom()
-        {
-            if (abilities == null || abilities.Length == 0) return null;
-
-            float total = noAbilityWeight;
-            for (int i = 0; i < abilities.Length; i++)
-                if (abilities[i] != null) total += abilities[i].Weight;
-
-            if (total <= 0f) return null;
-
-            float roll = UnityEngine.Random.Range(0f, total);
-            if (roll < noAbilityWeight) return null;
-            roll -= noAbilityWeight;
-
-            for (int i = 0; i < abilities.Length; i++)
-            {
-                var def = abilities[i];
-                if (def == null) continue;
-                if (roll < def.Weight) return def;
-                roll -= def.Weight;
-            }
-
-            return null;
-        }
     }
 }