LLM getNeighbours tool + contiguous region transfers (Stage 2 of #16 P2)

- llm.ts: LlmClient.chatWithTools — bounded OpenAI function-calling loop
  (default 6 tool rounds, then one forced no-tools request); shares the
  retry/backoff/reasoning-effort machinery with chat(); tools are only
  added to the request body when non-empty, so plain chat() bodies and
  their tests are unchanged; a tool-call response is a success (never a
  truncation); malformed tool arguments become an error tool-message.
- engine.ts: GET_NEIGHBOURS_TOOL + makeNeighboursExecutor (degrades
  unknown tools/args/keys without throwing); playerFrontier (sorted,
  deduped, other-nation-owned only); buildSystemPrompt gains a tool
  variant (contiguity rules, frontier hint) used only when the tool is
  actually sent; buildUserPrompt emits a frontier field whenever a
  resolver is given; runTurn takes getNeighbours and uses
  chatWithTools when both the resolver and the client's capability are
  present, falling back to plain chat() otherwise.
- applyTurnResult: snapshot-first sole-ownership algorithm — a region
  key transfers only with exactly one claimant and exactly one previous
  owner (different from the gainer); double claims and pre-existing
  double ownership are left untouched; lone losses are no-ops; every
  key has 0 or 2+ -> 1 owner post-turn, never orphaned or duplicated.
- stub.ts: deterministic one-region contiguous conquest per turn from
  the prompt's frontier field (bypasses the tool loop; empty frontier
  -> no transfer, all existing assertions stay stable).
- regions.ts: optional region-adjacency.json load; hasAdjacency() and
  neighboursOf(keys) (union, deduped, queried excluded, sorted).
- index.ts: jump route passes the adjacency resolver when loaded.
- tests: chatWithTools protocol (echo, executor args, bounded rounds,
  malformed args, retry), tool-path runTurn wiring + fallback,
  playerFrontier, executor, applyTurnResult invariants, neighboursOf/
  hasAdjacency (105 unit tests, 14 e2e — all green).

server/regions.test.ts

@@ -6,8 +6,10 @@ import path from 'node:path';
 import {
   allTerritoryKeys,
   expandCountriesToKeys,
+  hasAdjacency,
   hasRegionData,
   loadRegions,
+  neighboursOf,
   referenceForKeys,
   regionName,
   resetRegions,
@@ -89,6 +91,31 @@ describe('regions (region-key loader, v0.19 #16 P1)', () => {
     expect(allTerritoryKeys(state).size).toBe(58);
   });
 
+  it('hasAdjacency() is true: the region-adjacency manifest loaded (v0.21 #16 P2)', () => {
+    expect(hasAdjacency()).toBe(true);
+  });
+
+  it('neighboursOf returns the union of bordering keys (deduped, sorted, queried excluded)', () => {
+    // known mutual pairs from the manifest (verified in the Stage 1 spot checks)
+    const moselle = neighboursOf(['moselle-rygy']);
+    expect(moselle).toContain('baden-wurttemberg-oyje'); // FRA/DEU border
+    expect(neighboursOf(['baden-wurttemberg-oyje'])).toContain('moselle-rygy'); // mutual
+    expect(neighboursOf(['acre-ekzw'])).toContain('loreto-ipkx'); // BRA/PER border
+    expect(neighboursOf(['loreto-ipkx'])).toContain('acre-ekzw'); // mutual
+
+    // union + dedupe + sorted + the queried keys themselves excluded
+    const union = neighboursOf(['moselle-rygy', 'baden-wurttemberg-oyje']);
+    expect(union).toEqual([...union].sort());
+    expect(new Set(union).size).toBe(union.length); // no duplicates
+    expect(union).not.toContain('moselle-rygy');
+    expect(union).not.toContain('baden-wurttemberg-oyje');
+  });
+
+  it('neighboursOf returns [] for unknown keys or an empty set', () => {
+    expect(neighboursOf(['not-a-real-key-xyz'])).toEqual([]);
+    expect(neighboursOf([])).toEqual([]);
+  });
+
   describe('graceful degradation with no region data', () => {
     beforeEach(() => resetRegions());
 
@@ -99,6 +126,9 @@ describe('regions (region-key loader, v0.19 #16 P1)', () => {
       expect(referenceForKeys(['FRA'])).toEqual({});
       expect(validKeys().size).toBe(0);
       expect(regionName('FRA')).toBeUndefined();
+      // and no adjacency: the LLM tool / frontier field switch off
+      expect(hasAdjacency()).toBe(false);
+      expect(neighboursOf(['moselle-rygy'])).toEqual([]);
     });
   });
 
@@ -143,6 +173,15 @@ describe('loadRegions resolves the manifest per environment (dev public/ vs prod
     expect(validKeys().size).toBe(1796);
   });
 
+  it('a dist/ WITHOUT the adjacency manifest degrades: hasAdjacency() false, neighboursOf []', () => {
+    // this fixture copies only region-keys.json + regions.geo.json (no
+    // region-adjacency.json) — the server must boot and serve turns with the
+    // tool/frontier simply switched off.
+    expect(loadRegions(prodRoot)).toBe(true);
+    expect(hasAdjacency()).toBe(false);
+    expect(neighboursOf(['moselle-rygy'])).toEqual([]);
+  });
+
   it('returns false and no data when neither public/ nor dist/ holds the files', () => {
     const emptyRoot = path.join(base, 'empty');
     mkdirSync(emptyRoot, { recursive: true });