projects phase 4: cross-binary back, linkage-guided pre-warm, project verbs

Three things, all following from phase 3 making cross-binary jumps ordinary.

**A cross-binary jump was a one-way door.** Nav history is per-binary, so
arriving in another binary — a project search hit, or now following an import
into the library that implements it — landed you in an empty history with nothing
to take you back. _switch_then_goto records the binary it came FROM, and
action_back falls through to that hop once local history is spent: Esc walks back
through the function you were in, then the binary you were in. Manual Ctrl+O
switching records nothing, because that isn't navigation.

**Pre-warm follows the linkage graph, not list order.** _prewarm_provider warms
the binary providing the most of this one's imports — where a follow is most
likely to go, so its startup is paid before you ask for it. "Next in the list"
would have been arbitrary; phase 3 gave us something better to ask.

pool.prewarm() refuses rather than making room. Evicting a binary the user
visited to speculatively load one they haven't is a straight downgrade, and it
throws away that binary's caches as well; at a tight budget pre-warm just does
nothing. The cost of a worker that doesn't exist yet can only be estimated, so it
uses the largest resident one (same program, different database) — and if that
estimate proves wrong, the speculative worker is the one evicted, never a chosen
one.

**Driving a project.** pane spawn --project FILE [--open BIN]; `binaries` lists
the inventory (active / resident / indexed / where Esc returns to) and `switch
{binary,addr?}` makes another active — with an address it takes the search-hit
path, so it records a hop. state gains `binary` and `hops`, which it should have
had the moment project mode existed.

Verified on real sessions: drive binaries/switch against an echo+cat project
pane; Esc crossing back from a switch; and prewarm on echo+libc picking libc
(provider of echo's imports) and warming it after an evict.

tests: +5 pool (prewarm warms, no-ops when resident, refuses at budget, evicts
nothing when refusing, ignores unknown labels) and +4 project UI (jump records
the hop, Esc crosses back, hop consumed). Confirmed the Esc-back checks fail with
the branch removed. 195/0 scenarios, 27/0 project UI, 36/0 index, 27/0 pool,
33/0 project.

Left open: project-level persistence across sessions.

1 files changed, 31 insertions, 0 deletions

diff --git a/idatui/pool.py b/idatui/pool.py
index df852f8..25ea879 100644
--- a/idatui/pool.py
+++ b/idatui/pool.py
@@ -129,6 +129,37 @@ class WorkerPool:
         self._enforce_budget(protect=label)
         return client
 
+    def prewarm(self, label: str, progress=None) -> bool:
+        """Spawn a worker for ``label`` only if it fits the budget AS IT STANDS.
+
+        Pre-warming must never cost residency: evicting a binary the user
+        actually visited to speculatively load one they haven't is a straight
+        downgrade, and the eviction would also throw away that binary's caches.
+        So this refuses rather than making room, and returns False.
+
+        The cost of a worker that doesn't exist yet can only be estimated; the
+        largest resident one is the best evidence available (they are all the
+        same program with a different database). With nothing resident we have
+        no evidence at all, so we allow one — that is the case where the budget
+        is certainly free.
+        """
+        if label in self._clients:
+            return False
+        if self.project.by_label(label) is None:
+            return False
+        used = self.memory_mb()
+        est = max((self._mem(c) for c in self._clients.values()), default=0)
+        if used + est > self.budget_mb:
+            return False
+        self.get(label, progress=progress)
+        # get() enforces the budget protecting the NEW label; if that had to
+        # evict, our estimate was wrong and the speculative worker is the one
+        # that should go — never a binary the user chose.
+        if self.memory_mb() > self.budget_mb and label != self.active:
+            self.evict(label)
+            return False
+        return True
+
     def _touch(self, label: str) -> None:
         if label in self._lru:
             self._lru.remove(label)