Stage caching for batch runs, and an engine that lives in the command

A code node in a batch run is now fingerprinted by its source, its raw
settings and the values it reads — an artifact input counting as its digest,
which is what the content addressing was always for. A run that finds the key
restores what the earlier one returned and skips the node, recorded as
`cached`. The run history is the cache: `run_node.outputs` beside the
`cache_key` the schema already had, no second store. On for code nodes, never
for the built-in and connector types that have side effects; off per node with
`@node(cache=False)` and per run with `--no-cache`.

Emissions are not replayed on a hit, so a cached training node returns its
result without redrawing its curve. Recorded in NOTEPAD.md with the two other
deliberate limits.

`fluksio run --local` boots the real app in the command's own process and
drives it through its ASGI interface behind the ordinary client, so a run no
longer needs a `serve` terminal beside it — same data directory, same history,
and the cache carries between the two. It always waits, because the engine it
starts lives exactly as long as the command.

Also: `fluksio sweep --param lr=0.1,0.01` for the product of the lists,
`run --follow` for a run's numbers as they arrive, Ctrl-C cancelling a waited
run rather than abandoning it, coloured statuses on a terminal, and `name`
made optional on the metrics endpoint so a follower can ask for every series.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

backend/fluksio/sdk/client.py

@@ -197,13 +197,33 @@ class Client:
     # -- runs --------------------------------------------------------------
 
     def submit(
-        self, flow: str, params: dict[str, Any] | None = None, seed: int | None = None
+        self,
+        flow: str,
+        params: dict[str, Any] | None = None,
+        seed: int | None = None,
+        no_cache: bool = False,
     ) -> RunHandle:
         row = self._call(
-            "POST", f"/runs/flows/{flow}", json={"params": params or {}, "seed": seed}
+            "POST",
+            f"/runs/flows/{flow}",
+            json={"params": params or {}, "seed": seed, "no_cache": no_cache},
         )
         return RunHandle(self, row["id"], row)
 
+    def sweep(
+        self,
+        flow: str,
+        entries: list[dict[str, Any]],
+        no_cache: bool = False,
+    ) -> list[RunHandle]:
+        """Many runs of one flow at once. The caller decides what varies."""
+        rows = self._call(
+            "POST",
+            f"/runs/flows/{flow}/sweep",
+            json={"runs": entries, "no_cache": no_cache},
+        )
+        return [RunHandle(self, row["id"], row) for row in rows]
+
     def run(self, run_id: str) -> dict[str, Any]:
         result: dict[str, Any] = self._call("GET", f"/runs/{run_id}")
         return result