perf: Improve pathfinder

[andy5995]

Possible related to #277

We haven't tested this yet... I'll report back when we do.

The pathfinder's three std::map structures had significant per-iteration overhead from tree node allocation and O(log n) traversal:

• openNodesList (map<float, vector<Node*>>): replaced with a std::vector maintained as a binary min-heap using std::push_heap / std::pop_heap. Tie-breaking by insertion sequence number preserves deterministic expansion order.

• openPosList (map<Vec2i, bool>): replaced with std::unordered_set<Vec2i, Vec2iHash> for O(1) average membership tests instead of O(log n).

• closedNodesList (map<float, vector<Node*>>): eliminated entirely. The only use was finding the best partial-path node when the node limit is reached; this is now tracked with a single bestClosedNode pointer updated on each expansion.

Also align pathFindNodesAbsoluteMax (pool size) with pathFindNodesMax (search limit): both are now 2000, so the extended retry path can actually find more nodes than the normal search.

[andy5995]

It works in this example. I'm red, the AI is blue.

Before

After

(Zoom in and you will see little blue units all the way along the treeline from West to East)

But when I tested a longer game on ParaisoBR, I noticed some units would kind of move forward a few tiles, then back, then forward again, then back; with nothing actually blocking them. They kept moving though, and no units actually got stuck.

Claude says:

This PR makes two categories of improvement to the A* pathfinder.

1. Data structure optimisation (performance)

The pathfinder maintained three std::map structures that had significant per-iteration overhead from tree-node allocation and O(log n)
traversal:

• openNodesList (map<float, vector<Node*>>): replaced with a std::vector maintained as a binary min-heap using
  std::push_heap / std::pop_heap. Tie-breaking by insertion sequence number preserves deterministic expansion order.
• openPosList (map<Vec2i, bool>): replaced with std::unordered_set<Vec2i, Vec2iHash> for O(1) average membership tests instead of O(log
  n).
• closedNodesList (map<float, vector<Node*>>): eliminated entirely. The only use was finding the best partial-path node when the node
  limit is reached; this is now tracked with a single bestClosedNode pointer updated on each expansion.

pathFindNodesAbsoluteMax (pool size) is also aligned with pathFindNodesMax (search limit): both are now 2000.

2. Obstacle-avoidance pathfinding fix (correctness)

Units were getting permanently stuck when the path to their destination required a long detour around a large obstacle (e.g. a dense tree
cluster or mountain blocking the front of a base, with the only exit at the rear). They would pile up against the obstacle instead of
routing around it.

Root cause — three compounding bugs:

a) Dead retry condition. When A* exhausted its node budget, it was supposed to trigger an "exploratory retry" with a larger search. The
retry was gated on maxNodeCount != pathFindNodesAbsoluteMax, but since this PR equalized both values to 2000, the condition was always
false. The retry never fired.

b) Frame-tolerance function hardcoded off. The retry was also gated on Unit::isLastPathfindFailedFrameWithinCurrentFrameTolerance(), which
was unconditionally returning false due to a disabled feature flag (enablePathfinderEnlargeMaxNodes = false). Even if the first condition
had been met, the retry still could not fire.

c) Insufficient node budget. The normal search budget of 2000 nodes is enough for typical paths, but covers only roughly a 25-cell
exploration radius. A detour around a large obstacle can require 40–60+ cells of travel in the wrong direction first. 2000 nodes is not
enough to discover such a route.

Fixes:

• The dead maxNodeCount != pathFindNodesAbsoluteMax guard is replaced with an isExploratoryRetry flag that simply prevents infinite
  recursion, allowing the retry to fire whenever the node budget is exhausted on a normal (non-retry) search.
• isLastPathfindFailedFrameWithinCurrentFrameTolerance() is re-enabled with a 60-frame cooldown (~1.5 s at 40 fps), so units get one
  exploratory retry per cooldown period rather than never.
• A new pathFindNodesExploratoryMax = 8000 constant gives the retry a much larger search budget. The node pool is resized to match. Memory
  cost is approximately 2.3 MB across all 8 factions.
• The retry uses a reduced heuristic weight of 0.25 (down from 1.0). Standard A* with weight 1.0 strongly biases expansion toward the
  goal, which causes it to waste all its nodes pressing against the obstacle. At weight 0.25, the heuristic pull is much weaker and the
  search expands far more uniformly — closer to BFS — giving it a realistic chance of finding exits that lie in the opposite direction from
  the goal.
• The 200-node cap applied to repeatedly-stuck units is skipped for exploratory retries, since they need the full budget to do their job.

[andy5995]

But when I tested a longer game on ParaisoBR, I noticed some units would kind of move forward a few tiles, then back, then forward again, then back; with nothing actually blocking them. They kept moving though, and no units actually got stuck.

This is fixed now with the last commit, as far as I could tell from the testing I did.