feat(pipeline): cycle-aware scheduler and topo-sort safety (#245 layer 4)

[miguelgfierro]

Fourth layer of the unification (#245). `PipelineEngine` gains the ability to run cyclic DAGs (ReAct loops, retry-with-critique) and the long-standing silent corruption in `topological_sort`/`execution_levels` on cyclic graphs is fixed.

Stacked on layer 3 (#249) which is already merged into `issue-147-pipeline-evolution`.

New surface

```python
engine = PipelineEngine(
dag, # may contain cycles (allow_cycles=True)
state_schema=MyState,
recursion_limit=10, # NEW; default 25
)
```

How cycles work

`PipelineEngine.run()` checks `dag.is_cyclic()` and routes to a new `_run_cyclic` helper for cyclic graphs. Acyclic graphs continue to use the existing parallel topological scheduler — unchanged.

The cyclic scheduler:

1. Picks an entry node (insertion order, matching `StatePipeline`).
2. Executes; audits with the current visit count; checkpoints on success.
3. Walks each completed node's outgoing edges; picks the unique alive one as the next node.
4. Increments a per-node visit counter; if any node's visit count exceeds `recursion_limit`, halts with a clear failure message.
5. Stops when no outgoing edge is alive.

Cycle-mode is sequential within the cycle — multi-target alive fan-out (true parallel branches inside a cycle) is the job of `Send` in layer 5; for now multiple alive outgoing edges raise a clean `PipelineError`.

ReAct-style example

```python
class State(BaseModel):
counter: int = 0

dag = DAG("loop", allow_cycles=True)
dag.add_node(DAGNode(node_id="agent", step=ReActStep()))
dag.add_node(DAGNode(node_id="judge", step=JudgeStep()))
dag.add_edge(DAGEdge(source="agent", target="judge"))
dag.add_edge(
DAGEdge(source="judge", target="agent",
condition=lambda ctx: ctx.state.counter < 3)
)
engine = PipelineEngine(dag, state_schema=State, recursion_limit=10)
```

DAG silent-corruption fix

Both `topological_sort()` and `execution_levels()` previously misbehaved on cyclic DAGs:

• `topological_sort()` raised `PipelineError("DAG contains a cycle (should not reach here)")` — the message was wrong because the engine's new `allow_cycles=True` mode could indeed reach there.
• `execution_levels()` silently produced an incomplete list of levels (dropping nodes inside the cycle) with no error at all.

Both now raise `PipelineError` immediately, pointing the caller at `is_cyclic()` as the right precheck. This was the latent bug I flagged in the #245 review.

Audit visit numbers

`_record_audit` now accepts `visit=`. Acyclic scheduler passes `visit=1`; cyclic scheduler passes the actual iteration. `FileAuditLog.list_entries()` produces one entry per visit, distinguishable by the `visit` field. ReAct loops are debuggable.

Backward compatibility

• `recursion_limit` default of 25 matches `StatePipeline`.
• Acyclic engines are completely unchanged — no behavior diff, no perf cost.
• `PipelineEventHandler` legacy handlers continue to work; `visit` is only delivered to handlers that declare the parameter (the layer 1B dispatch handles this).

Tests

7 new tests in `tests/unit/pipeline/test_pipeline_engine_cycles.py`:

• `topological_sort` raises on cyclic DAGs
• `execution_levels` raises on cyclic DAGs
• ReAct-style finite loop terminates correctly
• Recursion limit halts runaway cycle
• Default `recursion_limit` is 25
• Audit visit number increments per iteration
• Acyclic DAG with `allow_cycles=True` still uses parallel scheduler

Full suite: 1580 passed.

What's NOT in this PR

• Parallel fan-out inside cycles — multiple alive outgoing edges from a cyclic node raise a clean error today; `Send` in layer 5 lifts that restriction.
• Mid-cycle resume — same caveat `StatePipeline` already has (resume across fan-out is not supported).
• Concurrent in-cycle execution — within a cycle, scheduling is sequential. Acyclic execution remains fully parallel.

Refs

• feat(pipeline): unify port-based and state-based pipelines into one DAG + engine #245 — unification design (layer 4 of 8)
• feat(pipeline): PipelineEngine checkpoint, audit, and resume (#245 layer 1) #246 / feat(pipeline): unified EventHandler protocol (#245 layer 1B) #247 — layer 1 (checkpoint/audit/resume + unified events)
• feat(pipeline): branching as DAGEdge.condition (#245 layer 2) #248 — layer 2 (DAGEdge.condition branching)
• feat(pipeline): state as optional overlay on PipelineEngine (#245 layer 3) #249 — layer 3 (state overlay)
• feat(pipeline): state-based PipelineBuilder — full #147 stack (phase 1+2+3a+3b+3c) #232 — umbrella PR