refactor[next]: replace workflow combinators with explicit typed pipelines

[egparedes]

The workflow-combinator framework introduced by ADR 0011 had grown to a dozen
abstractions to express what is, in the end, function composition. Measured
against actual use, only CachedStep was a deep module; the rest were shallow
wrappers around Callable[[S], T], and the reflection loop in
NamedStepSequence.__call__ was Any-typed, defeating the static typing
ADR 0011 prized.

The named pipelines become plain frozen dataclasses with an explicit, fully
typed __call__:

• backend.Transforms keeps its input-dependent step selection -- the match
  that used to live in step_order now lives in __call__, where the order is
  literally readable -- and the step_order method is retained only to raise,
  so a downstream override fails loudly instead of being silently ignored.
• recipes.OTFCompileWorkflow becomes backend.CompilePipeline and spells out
  its three steps; otf.recipes and otf.toolchain are deleted.
• Both take over emitting the stage_hook added in the previous PR. Names,
  order, count and artifacts are unchanged; the two instrumentation tests that
  assert the exact stage sequences pass unmodified, which is the proof.

Steps are now plain callables, named by the workflow.Step[S, T] alias, and
customization stays composition-time via dataclasses.replace. Deleted:
Workflow, ChainableWorkflowMixin, ReplaceEnabledWorkflowMixin,
NamedStepSequence, MultiWorkflow, StepSequence, make_step, .chain,
the three adapters in otf.toolchain, and the five adapted_*_factory
wrappers whose only job was to wrap a function into an adapter. CachedStep's
body is unchanged; it loses only the mixin bases, and with them .replace and
.chain.

Because steps no longer need to be adapter objects, the seven ffront factories
collapse to returning either the bare function or a CachedStep around it, and
the three per-step callers in decorator.py lose their wrap/unwrap dance.

What ADR 0011's decisions become: named steps with a visible order are now
dataclass fields plus an explicit __call__; statically typed composition is
checked end-to-end instead of through an Any-typed reflection loop;
customization at composition time is dataclasses.replace; and steps still
compose across backends because every existing step already satisfies
Step[S, T].

No behavior change, and -- unlike the naming PR -- no persistent cache key
rotates: fingerprints embed a class's qualified name and fields but never its
bases, and neither renamed pipeline is reachable from a persistent cache's
fingerprint graph.

Breaking, with no compatibility aliases: the deleted combinators and the
otf.recipes / otf.toolchain modules, .replace() / .chain() on the
classes that kept them via the mixins, overriding Transforms.step_order,
roundtrip.foast_to_gtir_step (now a data-only step), and
linter_factory(adapter=...) (the parameter was accepted and ignored).