perf(tui): unified Ink cache eviction on memory pressure + session reset

Adds an `evictInkCaches(level)` API that prunes the four hot module-level
caches (`widthCache`, `wrapCache`, `sliceCache`, `lineWidthCache`) with
either a half-keep LRU pass or a full clear. Wired into:

- memoryMonitor: half-prune on 'high', full drop on 'critical', before
  the heap dump / auto-restart path. Gives long sessions a shot at
  recovering RSS instead of hard-exiting.
- useSessionLifecycle.resetSession: half-prune so a /new session starts
  with a half-warm pool and the prior session can resume cheaply.

Also: lineWidthCache now uses LRU half-eviction on overflow instead of a
full `cache.clear()`, matching the other three caches.

Comparison vs claude-code: both forks now share the same `prevScreen`
blit + dirty-cascade machinery in render-node-to-output. Their smoothness
came from sibling-memo discipline (every chrome pane memo'd so dirty
cascade doesn't disable transcript blit) — already in place in our
appLayout.tsx (TranscriptPane / ComposerPane / StatusRulePane all memo'd).
Alt-screen is not the cause; both use it. The remaining gap was per-row
CPU on width/wrap/slice, which the previous commit closed.

ui-tui/packages/hermes-ink/src/ink/line-width-cache.ts

@@ -11,18 +11,35 @@ export function lineWidth(line: string): number {
   const cached = cache.get(line)
 
   if (cached !== undefined) {
+    cache.delete(line)
+    cache.set(line, cached)
     return cached
   }
 
   const width = stringWidth(line)
 
-  // Evict when cache grows too large (e.g. after many different responses).
-  // Simple full-clear is fine — the cache repopulates in one frame.
   if (cache.size >= MAX_CACHE_SIZE) {
-    cache.clear()
+    cache.delete(cache.keys().next().value!)
   }
 
   cache.set(line, width)
 
   return width
 }
+
+export function lineWidthCacheSize(): number {
+  return cache.size
+}
+
+export function evictLineWidthCache(keepRatio = 0): void {
+  if (keepRatio <= 0) {
+    cache.clear()
+    return
+  }
+
+  const target = Math.floor(cache.size * keepRatio)
+
+  while (cache.size > target) {
+    cache.delete(cache.keys().next().value!)
+  }
+}