Add tests for MIRV execution (#2767)

## Description:

This is a companion PR to
https://github.com/openfrontio/OpenFrontIO/pull/2765. It implements
tests and a performance benchmark for MIRV.

```bash
$ npm test -- tests/core/executions/MIRVExecution.test.ts

 ✓ tests/core/executions/MIRVExecution.test.ts (9 tests) 71ms
   ✓ MIRVExecution (9)
     ✓ MIRV should launch successfully 10ms
     ✓ MIRV should break alliances on launch 5ms
     ✓ MIRV should separate into warheads 20ms
     ✓ MIRV warheads should only target tiles owned by target player 15ms
     ✓ MIRV warheads should be distributed with minimum spacing 12ms
     ✓ MIRV should display warning message on launch 2ms
     ✓ MIRV should not launch if player cannot build it 2ms
     ✓ MIRV should not launch when targeting terra nullius 2ms
     ✓ MIRV should launch when targeting own territory without breaking alliances 2ms
```

```bash
$ npm tsx tests/perf/MIRVPerf.ts

...

=== MIRV Performance Benchmark Results ===
MIRV target selection - sparse territory x 53.53 ops/sec ±0.48% (71 runs sampled)
MIRV target selection - dense territory x 53.39 ops/sec ±0.57% (70 runs sampled)
MIRV target selection - giant world map (350 targets) x 1,129 ops/sec ±0.98% (90 runs sampled)
```

## Please complete the following:

- [ ] I have added screenshots for all UI updates
- [ ] I process any text displayed to the user through translateText()
and I've added it to the en.json file
- [x] I have added relevant tests to the test directory
- [x] I confirm I have thoroughly tested these changes and take full
responsibility for any bugs introduced

## Please put your Discord username so you can be contacted if a bug or
regression is found:

moleole

tests/perf/MIRVPerf.ts

@@ -0,0 +1,155 @@
+import Benchmark from "benchmark";
+import { dirname } from "path";
+import { fileURLToPath } from "url";
+import { MirvExecution } from "../../src/core/execution/MIRVExecution";
+import { PlayerInfo, PlayerType, UnitType } from "../../src/core/game/Game";
+import { setup } from "../util/Setup";
+
+// Setup sparse territory scenario (small target area)
+const sparseTerritoryGame = await setup(
+  "big_plains",
+  {
+    infiniteGold: true,
+    instantBuild: true,
+  },
+  [new PlayerInfo("player", PlayerType.Human, "client_id1", "player_id")],
+  dirname(fileURLToPath(import.meta.url)),
+);
+
+while (sparseTerritoryGame.inSpawnPhase()) {
+  sparseTerritoryGame.executeNextTick();
+}
+
+const sparsePlayer = sparseTerritoryGame.player("player_id");
+
+function claimRow(y: number, length: number) {
+  for (let x = 0; x < 200; x++) {
+    for (let dy = y; dy < y + length; dy++) {
+      const tile = sparseTerritoryGame.ref(x, dy);
+      if (sparseTerritoryGame.map().isLand(tile)) {
+        sparsePlayer.conquer(tile);
+      }
+    }
+  }
+}
+
+claimRow(0, 15);
+claimRow(40, 15);
+claimRow(90, 15);
+claimRow(140, 15);
+claimRow(185, 15);
+
+sparsePlayer.buildUnit(
+  UnitType.MissileSilo,
+  sparseTerritoryGame.ref(10, 10),
+  {},
+);
+
+// Setup dense territory scenario (large target area)
+const denseTerritoryGame = await setup(
+  "big_plains",
+  {
+    infiniteGold: true,
+    instantBuild: true,
+  },
+  [new PlayerInfo("player", PlayerType.Human, "client_id1", "player_id")],
+  dirname(fileURLToPath(import.meta.url)),
+);
+
+while (denseTerritoryGame.inSpawnPhase()) {
+  denseTerritoryGame.executeNextTick();
+}
+
+const densePlayer = denseTerritoryGame.player("player_id");
+
+for (let x = 0; x < 200; x++) {
+  for (let y = 0; y < 200; y++) {
+    const tile = denseTerritoryGame.ref(x, y);
+    if (denseTerritoryGame.map().isLand(tile)) {
+      densePlayer.conquer(tile);
+    }
+  }
+}
+
+densePlayer.buildUnit(UnitType.MissileSilo, denseTerritoryGame.ref(10, 10), {});
+
+// Setup giant world map scenario (realistic large-scale test)
+const giantMapGame = await setup(
+  "giantworldmap",
+  {
+    infiniteGold: true,
+    instantBuild: true,
+  },
+  [new PlayerInfo("player", PlayerType.Human, "client_id1", "player_id")],
+  dirname(fileURLToPath(import.meta.url)),
+);
+
+while (giantMapGame.inSpawnPhase()) {
+  giantMapGame.executeNextTick();
+}
+
+const giantMapPlayer = giantMapGame.player("player_id");
+
+// Conquer ALL available land tiles on the giant world map
+console.log("Conquering all tiles on giant world map...");
+let conqueredCount = 0;
+for (let x = 0; x < giantMapGame.map().width(); x++) {
+  for (let y = 0; y < giantMapGame.map().height(); y++) {
+    const tile = giantMapGame.ref(x, y);
+    if (giantMapGame.map().isLand(tile)) {
+      giantMapPlayer.conquer(tile);
+      conqueredCount++;
+    }
+  }
+}
+console.log(`Conquered ${conqueredCount} tiles on giant world map`);
+
+giantMapPlayer.buildUnit(UnitType.MissileSilo, giantMapGame.ref(800, 350), {});
+
+const results: string[] = [];
+
+new Benchmark.Suite()
+  .add("MIRV target selection - sparse territory", () => {
+    const targetTile = sparseTerritoryGame.ref(100, 100);
+    const mirvExec = new MirvExecution(sparsePlayer, targetTile);
+
+    mirvExec.init(sparseTerritoryGame, sparseTerritoryGame.ticks());
+
+    let ticks = 0;
+    while (mirvExec.isActive() && ticks < 1000) {
+      mirvExec.tick(ticks++);
+    }
+  })
+  .add("MIRV target selection - dense territory", () => {
+    const targetTile = denseTerritoryGame.ref(100, 100);
+    const mirvExec = new MirvExecution(densePlayer, targetTile);
+
+    mirvExec.init(denseTerritoryGame, denseTerritoryGame.ticks());
+
+    let ticks = 0;
+    while (mirvExec.isActive() && ticks < 1000) {
+      mirvExec.tick(ticks++);
+    }
+  })
+  .add("MIRV target selection - giant world map (350 targets)", () => {
+    const targetTile = giantMapGame.ref(2150, 800);
+    const mirvExec = new MirvExecution(giantMapPlayer, targetTile);
+
+    mirvExec.init(giantMapGame, giantMapGame.ticks());
+
+    let ticks = 0;
+    while (mirvExec.isActive() && ticks < 1000) {
+      mirvExec.tick(ticks++);
+    }
+  })
+  .on("cycle", (event: any) => {
+    results.push(String(event.target));
+  })
+  .on("complete", () => {
+    console.log("\n=== MIRV Performance Benchmark Results ===");
+
+    for (const result of results) {
+      console.log(result);
+    }
+  })
+  .run({ async: true });