script: compose the compile pipeline as typed weft arrows

[vinodhalaharvi-claude]

What

Step 1 of unifying on one arrow-driven, type-safe, composable pipeline. The compile phases were already arrow-shaped (func(ctx, A) (B, error)) but hand-chained with if err != nil ceremony. Now they're composed as actual weft.Arrow values via weft.Pipe — composition is real, type-checked at every seam, and the pipeline is itself an arrow that composes further.

Why

The mandate: everything type-safe, arrow-driven, composable — nothing built that can't be composed. A pipeline of bare functions glued by error checks isn't composition; it just resembles it. Building on weft's Arrow[A,B] + Pipe makes the composition literal and the type-safety structural (a phase whose output doesn't match the next phase's input won't compile).

Changes (pkg/script/submit.go)

• CompileArrow(reg) weft.Arrow[Source, sibyl.Plan] — the compile pipeline as one composed arrow:

  Pipe5(Parse, ResolveWith(reg), Lower, Finalize, Validate)

  weft.Compose handles error short-circuiting; the five if err blocks are gone.
• Compile is now CompileArrow(reg)(ctx, src) — same signature, same behavior, composed implementation.
• TranslateAndCompile composes Translate >=> Compile as Pipe2(translateArrow, CompileArrow(reg)).

weft promoted indirect → direct (now used directly). No behavior change — the demo compiles to the identical 2-node Plan; all existing tests pass.

Tests prove the composition property, not just that it works

compose_test.go:

• CompileArrow is assignable to weft.Arrow[Source, Plan] — compile-time proof of shape
• It composes into a larger arrow: Pipe2(CompileArrow, countNodes) runs end-to-end — the real composability test, the pipeline slots into Pipe like any arrow
• Error short-circuits through the composition (unknown builtin propagates, no partial plan)

loom is untouched (verified, not asserted)

loom's required surface — Compile, Submit, Translate, DefaultRegistry, CompleteFunc, ArityError, UnknownBuiltinError, registry.Registry — is preserved exactly. I built and tested loom against this commit with loom's own code unchanged: it builds clean, all tests pass. The change is in agentscript internals; loom doesn't notice.

Step	Result
go vet -structtag=false ./...	✅
gofmt -l .	✅
staticcheck ./pkg/script/...	✅
go test -race ./pkg/script/...	✅
go build ./...	✅
loom builds+tests against this commit	✅

Next (the unification roadmap, all on this composed spine)

• Step 2: add the memory interpreter branch — the same resolved AST runs in-process when the backend keyword is memory; temporal lowers to a Plan. One parser, two interpreters.
• Step 3: promote control-flow (if/foreach/match/fmap) from string-arg verbs to first-class composable AST nodes whose sub-expressions are arrows — never string-encoded sub-programs.
• Unify on the one complete registry-driven grammar; retire the redundant subset parser internals.