Add optional async mob pathfinding

[Rxflex]

Summary

Adds an opt-in feature that moves the expensive A* search in mob pathfinding
(PathFinder#findPath) off the main server thread onto a worker pool. Gated
per-world behind entities.behavior.async-pathfinding (default off).

How it works

• The request is prepared on the main thread (validation, world-border
  check, EntityPathfindEvent, PathNavigationRegion snapshot).
• Only the expensive A* search runs on a worker pool, using a
  thread-confined PathFinder created per call — the shared, mutable
  NodeEvaluator on this.pathFinder is never touched off-thread.
• The finished Path is applied back on the main thread via the server
  executor, so the world mutation model is unchanged.
• Only the create-and-apply moveTo(coords/entity, speed) overloads opt in;
  createPath(...) stays fully synchronous, so goals that inspect the path
  directly keep exact vanilla behaviour.

Safety / no-regression

• Exceptions in the worker fall back silently (mob recomputes next time).
• The pool uses a caller-runs policy with a bounded queue, so a saturated
  queue degrades to vanilla synchronous pathfinding — never worse than baseline.
• Default off; zero behavioural change unless explicitly enabled.

Measured impact

Synthetic in-process benchmark (200 mobs, obstacle field, hard targets),
per-path main-thread cost:

	main-thread cost / path
sync (async off)	~1003 µs
async (async on)	~91 µs

~90% of main-thread pathfinding cost removed on expensive paths (the case
that actually causes MSPT spikes: obstacle-dense areas, hard/unreachable
targets, villages/farms). On trivial paths the offload overhead makes it
roughly neutral — hence the opt-in default.

Notes

• This is an experimental, opt-in feature; it has not yet been validated under
  a real multiplayer load, only via the isolated microbenchmark above.
• Reading the live region/mob off-thread carries an accepted, bounded
  data-race tradeoff (as shipped by other forks), mitigated by the try/catch
  fallback.
• Follow-up: a thread-local PathFinder pool would cut the residual ~91 µs
  prep (dominated by per-call NodeEvaluator allocation) further.