opentui(phase3): launcher integration — HERMES_TUI_ENGINE dual-engine

hermes --tui launches the native OpenTUI engine (Bun) when
HERMES_TUI_ENGINE=opentui (env) or display.tui_engine=opentui (config);
Ink stays the default and the shipping path is untouched.

- _resolve_tui_engine() (env > config > ink); refuses opentui on
  Windows/Termux (no Bun) -> falls back to ink with a notice.
- _make_opentui_argv() -> [bun, src/entry.real.tsx] (no build step).
- _bun_bin() with HERMES_BUN override.
- Branch at top of _make_tui_argv BEFORE _ensure_tui_node (Bun-only host
  must not bootstrap Node).
- Gate _launch_tui NODE_OPTIONS/--max-old-space-size on engine==ink (Bun
  is JSC; the V8 flag errors/ignores).

Verified end-to-end via tmux: real hermes --tui -> Bun -> OpenTUI ->
real Python gateway streamed a real reply. No-flag default still ink.

tests/gateway/test_compression_concurrent_sessions.py

@@ -146,30 +146,6 @@ def test_concurrent_compressions_same_session_serialize(tmp_path: Path) -> None:
     agent_a = _build_agent_with_db(db, shared_sid)
     agent_b = _build_agent_with_db(db, shared_sid)
 
-    # Force genuine simultaneous lock contention instead of relying on a
-    # ``time.sleep`` inside the compressor stub to make the threads overlap.
-    # Under CI CPU starvation that sleep is not enough: one thread could
-    # acquire → compress → rotate → RELEASE the lock before the other even
-    # reaches ``try_acquire``, so both would acquire on the shared id and
-    # both would compress (the historical "got 2" flake). A two-party
-    # barrier in front of the real acquire guarantees both threads are
-    # contending for the lock at the same instant, which is exactly the
-    # condition this test means to assert — with zero timing dependency.
-    barrier = threading.Barrier(2, timeout=15)
-    _real_acquire = db.try_acquire_compression_lock
-
-    def _barriered_acquire(*args, **kwargs):
-        # Rendezvous both callers, then let the real (atomic) acquire decide
-        # the single winner. Tolerate a broken barrier so a test-side timeout
-        # never masquerades as a lock-logic failure.
-        try:
-            barrier.wait()
-        except threading.BrokenBarrierError:
-            pass
-        return _real_acquire(*args, **kwargs)
-
-    db.try_acquire_compression_lock = _barriered_acquire
-
     results: dict[str, list | None] = {"a": None, "b": None}
     errors: list[Exception] = []
 
@@ -187,10 +163,6 @@ def test_concurrent_compressions_same_session_serialize(tmp_path: Path) -> None:
     t_a.join(timeout=15)
     t_b.join(timeout=15)
 
-    # Restore the real method so the post-join lock-leak assertion below
-    # (and any future call) hits the unwrapped implementation.
-    db.try_acquire_compression_lock = _real_acquire
-
     assert not errors, f"Compression raised exceptions: {errors}"
 
     # Count which agents actually compressed (returned fewer messages than input)