Feat: chunk oversized compaction requests and escalate tail reduction

Fixes #48844
Depends on / includes #48828 — the first commit on this branch is that PR's loop guard; the escalation ladder builds on its streak machinery. If #48828 merges first, this PR's diff reduces to the second commit.

Problem

Compaction fails exactly when it is most needed. select() budgets only the retained tail; the serialized head is sent to the summarizer as a single unbudgeted request. A session that outgrows its model's window therefore produces a summarization request that doesn't fit, and compaction dies with Session too large to compact (observed live on a ~60k-token session with a 64k-context model). Two further issues compound it:

• With a dedicated compaction model configured (agent.compaction.model), the retained-tail budget was derived from the compaction model's window instead of the session model's — e.g. a 1M-window compactor retains a 15k-token tail for a 64k-window session, which then permanently overflows.
• A failed auto-compaction (post-compaction context still overflows) retried with the same tail budget, failing identically until the fix(session): stop looping auto-compaction when it cannot restore context headroom #48828 loop guard stopped the session.

Fix

Chunked (map-reduce) summarization. New reduceContexts step between serialization and the persisted summary call:

• The serialized head is packed into chunks capped at 0.5 × usable window of the compaction model (estimate-based, with a 2× safety margin against the 4-chars/token heuristic).
• Each chunk is summarized via an ephemeral, unpersisted LLM.stream call; partial summaries that still exceed the budget are packed and re-summarized (≤ 4 merge rounds, practically 1).
• Only the final, fitting summary request goes through the persisted processor path — events, token accounting, and error handling for it are unchanged.
• Sessions whose head fits take the previous single-request path unchanged (byte-identical prompt). Models with unknown limits (context: 0) skip chunking entirely, preserving current behavior.

Session-model tail budget with an escalation ladder. select() now sizes the retained tail from the session model (whose window the compacted session must fit), and repeated failed auto-compactions shrink it: full → half → none (retaining nothing means the compacted context is summary-only). The streak comes from the #48828 failedAutoCompactions machinery; the loop guard's limit becomes the ladder length (3 attempts, then the session stops with an actionable error).

Validation

• Unit tests: chunkSerialized packing/truncation (4 cases), preserveRecentBudget escalation ladder incl. clamping and explicit-config scaling (4 cases).
• Integration tests (real compaction pipeline against a fake LLM): oversized head is summarized in budget-fitting chunks (asserts every request, chunk and final, is under budget); bloated partial summaries trigger a merge round; first auto-compaction retains the tail; after two failed auto-compactions the retained tail is dropped (tail_start_id unset).
• Full package suite: 3602 pass / 0 fail; tsgo --noEmit clean.
• Repro scenario: with compaction model deepseek/deepseek-v4-flash (1M) and session model cerebras/qwen-3.8-27b (64k), a ~60k-token session that previously died with Session too large to compact now takes the single-request path (the head fits the compactor's 1M window), and the session-model-derived, escalating tail budget lets the compacted session fit qwen's 33.5k usable window. The integration tests cover the chunked path with a 20k-context model.

Follow-ups (not in this PR)

• Chunk summarization calls are ephemeral and their token usage is not tracked in session stats.
• Chunk calls don't take the session abort signal; cancellation takes effect between chunk requests rather than mid-request.
• The core native-runtime compaction engine (@opencode-ai/core/session/compaction) fails safe (return false) on oversized prompts but doesn't chunk; it could adopt the same map-reduce helper.