feat(pipeline): Pause and Send in unified PipelineEngine (#245 layer 5)

[miguelgfierro]

Fifth layer of the unification (#245). `PipelineEngine` now recognizes the same control sentinels that `StatePipeline` uses today — `Pause` (HITL) and `Send` (runtime fan-out).

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

Pause: HITL halt + resume

```python
async def await_approval(ctx, inputs):
return Pause(reason="awaiting human approval to deploy")

engine = PipelineEngine(dag, state_schema=State, checkpointer=cp)
paused = await engine.run(inputs="...")
assert paused.paused is True
assert paused.paused_node == "await_approval"

Later, after approval:

resumed = await engine.run(run_id=paused.run_id, approve_pause=True)
```

Behavior:

• The engine writes a checkpoint with `paused=True` and the reason.
• `PipelineResult` carries `paused`, `paused_node`, `pause_reason`.
• Resuming a paused checkpoint without `approve_pause=True` raises `PipelineError` with the reason surfaced.
• The pause node is not re-executed on resume; the successor runs next.

Send: parallel fan-out

```python
async def planner(ctx, inputs):
return [Send(target="worker", payload={"items": [i]}) for i in items]
```

• A node may return a single `Send` or `list[Send]`.
• Each Send's `payload` is applied to a per-worker state copy via reducers — workers do not race on shared state.
• Workers run concurrently via `asyncio.gather`.
• Worker outputs merge back into shared state via reducers.
• Workers are marked completed so the topological scheduler doesn't re-run them.

Refactor

`Pause` and `Send` dataclasses moved from `state_pipeline.py` to `engine.py`. This breaks what would otherwise be a circular import; `state_pipeline.py` now imports them from `engine`. Public re-exports from `fireflyframework_agentic.pipeline` are unchanged — `from fireflyframework_agentic.pipeline import Pause, Send` still works.

Engine changes

• `run()` accepts `approve_pause: bool = False`.
• `_save_checkpoint` accepts `paused=`, `pause_reason=` kwargs (persisted on `CheckpointRecord`).
• `_load_for_resume` enforces the `approve_pause` gate.
• New `_run_sends` helper drives the fan-out.
• New `_is_send_payload` module-level discriminator.

Result changes

`PipelineResult` gains: `paused: bool`, `paused_node: str | None`, `pause_reason: str | None`. Mirrors `StatePipelineResult`.

Tests

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

• Pause halts pipeline; result + checkpoint reflect paused state
• Resume without `approve_pause=True` raises with reason
• Resume with `approve_pause=True` continues from successor
• `list[Send]` dispatches workers concurrently with per-worker state
• Single `Send` is treated as list of one
• Unknown Send target marks the pipeline as failed
• `Pause` / `Send` re-exports stable

Full suite: 1587 passed.

What's NOT in this PR

• Pause inside cyclic mode — `_run_cyclic` doesn't yet handle Pause; that's a follow-up. The acyclic scheduler covers most HITL use cases.
• Cross-fan-out resume — same caveat `StatePipeline` already has. A run paused mid-fan-out can't be cleanly resumed across worker boundaries.

Refs

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