Adds optional `metadata.tokenUsage` to `ToolResult` so tools that perform
nested LLM work can report their consumption. `delegate_to_agent` now sets
it from the delegated `AgentRunResult.tokenUsage`, and the runner rolls
each turn's delegation usage into its `totalUsage` before the next
`maxTokenBudget` check.

Closes the non-blocking review item from PR #84: without this, a parent
agent could issue delegations that silently bypass its own budget cap.

Adds `TeamInfo.delegationChain` (readonly string[]) tracking the chain of
agents from the root task to the current one. The orchestrator seeds it
with the top-level assignee and appends each target on recursive
`runDelegatedAgent` calls. `delegate_to_agent` checks whether the target
is already in the chain before the depth check and rejects with the full
chain in the error message.

Closes the non-blocking review item from PR #84: without this, an
A -> B -> A cycle would burn up to `maxDelegationDepth` LLM calls before
aborting. It now aborts on the first cycle attempt.

Both `compressConsumedToolResults` (turn-based marker replacement) and
the `compact` context strategy now skip tool_result blocks whose
originating tool_use was `delegate_to_agent`. Delegation output often
carries the full sub-agent answer the parent needs to reason over in
later turns; compressing it leaves the parent with a meaningless
placeholder.

Error results and short results are still handled as before.

Documents delegate_to_agent: opt-in registration, guard order
(self/unknown/cycle/depth/pool), parent-run tokenUsage aggregation,
compression/compact exemption, and SharedMemory audit. Notes that
standalone runAgent and the runTeam short-circuit path do not inject
the tool. Also lists glob in the built-in tool set.

…tion deadlock

AgentPool.run acquires a per-agent lock meant to serialize concurrent
mutations of a shared Agent instance. When two parent tasks mutually
delegate (A→B while B→A), each nested pool.run waited on the other
agent's lock forever — even with free pool slots — because both parents
held their own lock until their tool call returned.

Delegation already promises "a fresh conversation for this prompt only",
so reusing the long-lived pool Agent was the wrong target. Each
delegation now:
- looks up the target AgentConfig from the team roster,
- applies orchestrator defaults (provider / baseURL / apiKey),
- builds a temporary Agent via buildAgent(..., { includeDelegateTool: true }),
- runs it via the new AgentPool.runEphemeral, which acquires only the
  pool semaphore.

The lock-based deadlock becomes structurally impossible. Parallel
delegations to the same target now each get their own temp instance
instead of queueing on a shared lock.

Addresses Codex P1 on PR #123.