perf: fuse pipelines whose intermediates are temporaries

`(reduce + (map g (filter p (range n))))` built two complete sequences only to
walk each once. Fusing the stages into a single loop removes them: no chunks,
no cursors between stages, and with a range base no sequence at all -- the
integers are generated in the loop.

  seqs                 136 ms -> 44 ms   (jolt: 109 ms)
  5M-element pipeline  786 ms -> 168 ms, and 713 MB -> 5 MB

The memory drop is the same head-retention problem noted when chunking landed:
a fold held its argument, so every realized chunk stayed reachable. A fused
pipeline never builds one.

Safety is the whole design, because fusion and memoisation conflict: a lazy
seq computes each element once and caches it, and a fused consumer recomputes.
The first attempt fused in the runtime, which broke exactly that -- counting a
named `(map f coll)` twice ran f twice. seqlib caught it.

So the decision moved to the compiler, which can prove what the runtime cannot:
fusion applies only when the intermediate sequences are syntactic temporaries,
nested directly inside the consuming call. Nobody named them, so nobody can
observe their memoisation. A named pipeline compiles as it always did:

  (reduce + (map f (range 10)))        fused -- the map seq is a temporary
  (def ys (map f coll)) (reduce + ys)  not fused -- ys memoises

The base is left alone either way, so a named lazy source still realizes and
caches normally; only a range base is regenerated rather than walked, which is
safe because range is pure. Shadowing or `def`-ing any of reduce/count/map/
filter/remove turns fusion off, through the same primStable check the other
optimisations use.

tryExpr declines a fusable pipeline so it compiles as statements, which is what
keeps operands evaluating in source order -- Nim would otherwise evaluate the
base before the stage fns, where Clojure evaluates the reducing fn, then each
stage outermost-in, then the base.

examples/fusion.clj pins all of it: results identical fused and unfused, both
memoisation cases, evaluation order, every base kind, empty and init-carrying
folds, and the shadow and rebind escapes. Every case was checked against a
real Clojure run.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>