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/scripts/bench_engine.py

@@ -198,14 +198,18 @@ class Engine:
     def drain(self, timeout: float = 60.0) -> bool:
         """Wait for the queue to go quiet. False means it never did.
 
+        Asks the backlog rather than the whole of ``stats()``: the health
+        summary's version costs four round trips, and polling it every twenty
+        milliseconds competes with the engine for the connection it is
+        supposedly measuring.
+
         Delayed items are not waited for: a rate-limit flush is due a whole
         window from now, and the scenario is over long before that.
         """
         deadline = time.monotonic() + timeout
         quiet_since = 0.0
         while time.monotonic() < deadline:
-            stats = self.service.stats()
-            busy = stats.get("cascades_busy", 0) or stats.get("backlog", 0)
+            busy = self.service.inflight or self.queue.backlog()
             if not busy:
                 # Two consecutive quiet reads: a cascade between claim and ack
                 # shows as neither.