✨ Run spawned document work concurrently with <All> (#855)

[taras]

Why

A document could not run two pieces of work at the same time. Everything a
document does is sequential, so two <Session> conversations, two long reads or
two independent sub-documents run one after another even when neither needs the
other's result. #827's agent sessions need concurrent work, and #854's REPL needs
two live conversations at once, so this is the structural primitive they are
both waiting on.

What changes

Before:

<Session agent="claude">…</Session>
<Session agent="codex">…</Session>

Two conversations, one after the other. Nothing in the language can say they are
independent.

After:

<All>
  <Spawn><Session agent="claude">…</Session></Spawn>
  <Spawn><Session agent="codex">…</Session></Spawn>
</All>

Both run at the same time. <All> waits for every <Spawn> child and renders
their Markdown in authored order even when they finish in another order, so
the document reads the same however the work interleaved.

Each <Spawn> is its own child: bindings made in one stay in it, and a <Return>
or <Break> inside one cannot target work outside it. A <Spawn> anywhere but
directly inside <All> is refused before the document runs, and so is an <All>
with fewer than two <Spawn> children.

Under a durable run the children are joined through durableAll(), so each child
is a coroutine of its own in the Journal and a replay resumes them the same way.

How it works

<All> → one child per <Spawn> → all()/durableAll() → children rendered in authored order

Two identity mechanisms had to stop being execution-wide for this to work at
all, because concurrent children resolve components at the same time:

• Import frames (invocation-identity.ts) are now one LIFO stack per
  Effection scope rather than one per execution. Two children importing at once
  no longer see each other's frame.
• Resolution windows (component-resolution.ts) are likewise per scope, and
  a provider's issuance is spent against the window that asked for it rather than
  against whatever window happened to be innermost.

Both were found by measurement: two ordinary <Session> invocations under <All>
failed with ComponentInvocationError until ownership followed the scope.

Review guide

Start with: packages/core/tests/all.test.ts

Then review:

1. packages/core/src/structural.ts and structural-rules.ts — what the syntax
   is, and what is refused before anything runs
2. packages/core/src/expand.ts — expandAll(), spawnChild(),
   spawnEnvironment(), and the live/durable join
3. packages/core/src/invocation-identity.ts and
   components/component-resolution.ts — per-scope ownership
4. specs/executable-mdx-spec.md and architecture.md

Look carefully at:

• The join: finishing order and append order are deliberately separate, and the
  rendered output is authored order in both the live and the durable path.
• Containment: a child's <Return>/<Break> and its bindings stop at its own
  boundary.

What must stay true

• <All> renders in authored order — enforced by collecting each child's result
  positionally and checked by ALL6 and the <All>-of-<Session> rows.
• A <Spawn> outside <All> is a document error, not a runtime one — enforced by
  spawnElementViolations()/misplacedSpawnViolations() and checked in
  all.test.ts.
• Concurrent children resolve their own components — enforced by per-scope frames
  and windows, checked by the concurrent rows in answer-identity.test.ts and
  invocation-identity.test.ts.
• The complete structural vocabulary stays frozen — syntax-catalog.test.ts SY4c
  and syntax-cli.test.ts SX2b now include All and Spawn.

How to verify it

• deno task test packages/core/tests/all.test.ts proves the syntax, the
  refusals, isolation, ordering and the durable join, and fails if a child's
  bindings escape or output follows finishing order.
• The concurrent identity rows prove two children resolving at once each get
  their own answer, and fail if a frame or window is shared — which is exactly
  what happened before this change.

Scope

Included

• <All>/<Spawn> syntax, validation, expansion and durable join
• Per-Effection-scope import frames and resolution windows
• The frozen-vocabulary corrections that follow from adding two constructs
• test-weights.json from run 36473005680 at b14a2ba1

Intentionally unchanged

• No concurrency limit, no cancellation policy beyond what a failing child
  already does: a child's failure raises into its owner as any task does.
• <All> is not an iteration construct; <Loop> is unchanged.

Generated or mechanical changes

• test-weights.json is the artifact of Measure test weights run
  36473005680 at b14a2ba1, committed unchanged. Nothing was hand-edited, and no
  shard recalibration is included.

Risks and limitations

• This PR is stacked on Run a Plan and follow its Agent sessions in the REPL #854 Slice A (✨ Slice A of #854: retain a safe Agent permission audit and project Agent conversations #857), which is this work's frozen base.
  It is targeted at agent/issue-854-projection so the diff here is Run spawned document work concurrently with <All> #855's own
  work; once ✨ Slice A of #854: retain a safe Agent permission audit and project Agent conversations #857 merges, this branch is rebased onto updated main, its focused
  delivery evidence re-run, and this PR retargeted to main. It closes Run spawned document work concurrently with <All> #855
  only — Run a Plan and follow its Agent sessions in the REPL #854 stays open.

Scope confirmation

• Every changed file supports the purpose described above.
• Unrelated cleanup and formatting changes are excluded.
• Generated or mechanical changes are clearly identified.
• The description matches the final diff and test results.

Closes #855