feat(§29): implement parallel step execution with std::thread::scope

[AlexChesser]

Completes the §29 implementation on top of the Phase 1-3+6 foundations already on main (#151). This adds the actual parallel dispatch so async: true steps run concurrently instead of being treated as sequential.

Closes #117.

Summary

• async: true steps launch on scoped threads and run concurrently with subsequent sequential steps, with forked Session state (cloned turn log snapshot, isolated http_session_store when resume: false).
• action: join synchronizes branches and merges outputs — string join (default, [step_id]:\n<response> headers) or structured join (namespaced JSON when all deps declare output_schema, optionally validated against the join's own schema).
• on_error: fail_fast (default) surfaces the first branch failure; on_error: wait_for_all collects error envelopes into the merged JSON for post-hoc inspection.
• defaults.max_concurrency enforced via a Mutex<usize> + Condvar semaphore — no new dependency, no async runtime.
• Turn log entries tagged with concurrent_group, launched_at, completed_at ISO 8601 timestamps (§29.8).
• Dotted-path template resolution: {{ step.<join>.<dep>.<field> }} walks JSON paths through structured join responses (§29.6).

Implementation notes

• New module ail-core/src/executor/parallel.rs — ConcurrencySemaphore, BranchResult, merge_join_results, civil-calendar timestamp helpers (no chrono dependency).
• execute_core branches to a new execute_core_with_parallel path when any step is async. The parallel variant wraps the main loop in std::thread::scope so async launches coexist with sequential steps executed on the main thread.
• Runner signatures updated to &(dyn Runner + Sync) on the parallel path; all concrete runners were already Sync by composition. RunnerFactory now returns Box<dyn Runner + Send + Sync>.
• TurnEntry gains Clone for session forking.
• Session::fork_for_branch(isolated_http: bool) clones entries into a NullProvider-backed TurnLog and mints a fresh http_session_store when resume: false (SPEC §29.9 opt-out of context inheritance).
• execute_single_step no longer handles action: join directly — joins are fully coordinated in execute_core_with_parallel.

Tests

ail-core/tests/spec/s29_parallel.rs — 23 new tests:

• Parse-time validation (9): orphaned async, join without depends_on, forward references, cycles, concurrent resume: true conflict, mixed structured/unstructured deps, action: join recognition, on_error mode parsing, max_concurrency parsing.
• Runtime execution (9): two-async-plus-join end-to-end, runner invocation count, string-join declaration order, sequential step sees join result, condition: never on async unblocks join, on_result on join fires abort/continue, regression for non-async pipelines, max_concurrency: 1 serialization, shared concurrent_group metadata.
• Fixture round-trips (5): parallel_basic, parallel_structured, and three invalid-case YAML fixtures.

Full suite: 504 passed, 0 failed (previous 481 + 23 new §29 tests).

Quality gates

• cargo build ✅
• cargo clippy -- -D warnings ✅
• cargo fmt --check ✅
• cargo test ✅ (504 passed)

Docs

• spec/core/s29-parallel-execution.md status → implemented (v0.3).
• spec/README.md entry updated.
• CLAUDE.md and ail-core/CLAUDE.md updated with new template variables, executor/parallel.rs module responsibility, Known Constraints entry for §29, and updated Step / ActionKind / JoinErrorMode key types.
• CHANGELOG.md v0.3 in-progress entry.

Deferred (spec-authorized)

• Mid-flight runner-level cancellation for fail_fast — branches complete on their own; first error still propagates. SPEC §29.7 explicitly declares cancel signals "best effort".
• Controlled-mode executor events for async launches.

Test plan

• Existing test suite still passes (504 tests).
• New §29 tests exercise each validation rule and runtime path.
• Sequential-only pipelines take the fast path (no scoped-thread overhead).
• RecordingStubRunner confirms both async branches actually invoke the runner.
• Structured-join response is valid JSON with namespaced keys.
• concurrent_group metadata is present on branch entries and shared across siblings.

https://claude.ai/code/session_01RYo2Rp8t2RkV5R8rfJrd3W