Stop paying five Redis round trips and a global lock per message

The engine was I/O-bound on its own state backend. `RedisState.lock()` is one
key — `pipeline:_lock` — for the whole process, taken five times a message at
two round trips each, and every cascade and every node read queued behind it.
Inside it, reading a node's inputs was three round trips per input (an EXISTS
for `in`, then EXISTS and GET for the value), writing was two updates that a
single transaction already gives, and the version counters went one INCR at a
time.

Replaced with the atomic command that was always available: `get_present` is
one MGET and tells a missing key from one holding null, so the lock it used to
be read under bought nothing; value and timestamp land in one `update`, which
is a MULTI/EXEC; `increment_multi` pipelines the counters. `values()` — what
every websocket snapshot calls — is two reads whatever the message count
instead of two per message.

Beside that: every webhook did its blocking XADD on the asyncio event loop
(MQTT already used `to_thread`); the per-execution `NodeOutcome` was built and
validated even with no run watching; `_minute` built a tz-aware datetime per
event on the loop thread to key a dict, and now keys on an int; `move_due`
promoted delayed items one round trip each, every second; `FLOW_MAX_CASCADES`
makes the in-flight ceiling a setting rather than a constant.

`orjson` replaces stdlib json where a message pays for it — state, the
journal, the engine side of the worker pipe. `fluksio-worker` stays
dependency-free, and the run-cache digest stays on stdlib so no stored key is
invalidated. A non-finite number now stores as `null` rather than the bare
`NaN` that was never JSON.

Measured with `scripts/bench_engine.py` against a real Redis, 200 messages:
a five-node chain went from 43.9 to 103.1 msg/s with p50 latency 2110ms →
782ms and p95 3913ms → 1439ms; one source into twenty consumers went from 5.4
to 33.7 msg/s. In memory, twenty consumers went from 187 to 448 msg/s.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01BpfSinyCBfjuieikyfMPbf

backend/fluksio/flow/workers.py

@@ -14,7 +14,6 @@ from __future__ import annotations
 
 import hashlib
 import itertools
-import json
 import logging
 import os
 import queue
@@ -28,6 +27,7 @@ from collections.abc import Callable
 from pathlib import Path
 from typing import Any
 
+import orjson
 from fluksio_worker import worker_main as _worker_main
 
 from fluksio.flow.events import EventBus
@@ -155,7 +155,12 @@ class _Worker:
 
     def send(self, request: dict[str, Any]) -> None:
         assert self.proc.stdin is not None
-        self.proc.stdin.write((json.dumps(request) + "\n").encode())
+        # Node inputs may be keyed by something other than a string, which
+        # the stdlib encoder this replaced turned into strings rather than
+        # refusing.
+        self.proc.stdin.write(
+            orjson.dumps(request, option=orjson.OPT_NON_STR_KEYS) + b"\n"
+        )
         self.proc.stdin.flush()
 
     def read_line(self, deadline: float) -> str | None:
@@ -414,7 +419,7 @@ class PythonWorkerPool:
             )
             if line:
                 try:
-                    message = dict(json.loads(line))
+                    message = dict(orjson.loads(line))
                 except (TypeError, ValueError) as exc:
                     # A reply we cannot read leaves this worker out of step:
                     # whatever is still in its pipe would be taken by the