runtime: multi-module supervisor + block/log event loop

[brunota20]

Draft, stacked on top of #8 — the diff includes that PR's commits until #8 lands.

This is the next layer: turns `main` from a single-module bootstrap that fires one test event into a multi-module supervisor that drives the engine off live `eth_subscribe` streams.

Schema additions

`engine.toml` grows `[[modules]]` entries:

```toml
[[modules]]
path = "./modules/twap/twap.wasm"
manifest = "./modules/twap/nexum.toml" # optional; defaults to sibling
```

`nexum.toml` grows `[[subscription]]` entries (tagged enum, matches the schema in `docs/02-modules-events-packaging.md`):

```toml
[[subscription]]
kind = "block"
chain_id = 11155111

[[subscription]]
kind = "log"
chain_id = 11155111
address = "0xfdaFc9d1902f4e0b84f65F49f244b32b31013b74"
event_signature = "0x..."

[[subscription]]
kind = "cron"
schedule = "*/5 * * * *" # parsed + warned; dispatch lands in 0.3
```

Unknown `kind` values surface at load time so a typo does not silently disable an event source. Cron is parsed and logged with a "declared but inert in 0.2" warning per the docs/02 lifecycle.

Multi-module loading

`supervisor::Supervisor::boot` iterates `engine_cfg.modules`, compiles each `.wasm` into its own wasmtime `Store`, runs `_init` with the manifest's `[config]`, and surfaces the subscriptions the event loop will wire. One `Engine` + `Linker` is shared across modules; `cow_pool` / `provider_pool` / `local_store` are cloned into each `HostState`; the per-module namespace comes from `manifest.module.name`.

A positional CLI `` still works for the single-module `just run` path — the supervisor synthesises a one-module config in that case, so backwards compat is preserved.

Event loop

`ProviderPool` gains `subscribe_blocks` + `subscribe_logs` returning boxed alloy streams typed `Result<Header, ProviderError>` and `Result<Log, ProviderError>`.

`main` opens:

• one shared block subscription per chain id any module asked for, then
• one log subscription per `(module, filter)` pair,

tags each stream with `chain_id` / `module_name`, and merges via `select_all`. Block events go to every subscribed module; log events go only to the owning module. `on_event` failures surface as `tracing::warn!` (host-error returned by guest) or `tracing::error!` (wasm trap).

SIGINT / SIGTERM (Unix) or ctrl-c (else) exits the loop cleanly.

Out of scope (deliberate, per the 0.3 roadmap)

• Restart + poison-pill bookkeeping. Failing `_on_event` is logged but the module continues to receive subsequent events. The full Resolve→Load→Init→Run→Restart→Dead lifecycle from `docs/02` lands alongside the `[module.restart]` schema in 0.3.
• Cron dispatch. Parsed + warned today; tokio-time-driven scheduler in 0.3.
• Content-addressed resolution. Module `path` is a local filesystem entry in 0.2 — Swarm / OCI / ENS / `[[content.sources]]` from `docs/03` lands in 0.3.

Test surface

`cargo test -p nexum-engine --bins`: 15 passed (one new — empty supervisor returns empty subscription sets). Existing `cow_orderbook` + `provider_pool` + `local_store` tests untouched.

```
cargo fmt --all --check # clean
RUSTFLAGS=-D warnings cargo clippy --all-targets # clean
just run # example.wasm boots through the supervisor,
# exits cleanly with "no [[subscription]]"
```

Open questions

1. CLI surface. I went with `--engine-config ` + positional ` ` for backwards-compat. If you'd rather drop the positional shortcut and require `engine.toml` in production, easy to strip.

2. Block dispatch chains-per-stream. Today one block subscription per chain serves every module subscribed to that chain (shared subscription, per the docs/01 "shared subscriptions" line). If you'd rather one subscription per (module, chain) for clearer attribution, the structure carries through — `open_block_streams` is the only change.

3. Log filter granularity. `[[subscription]] kind="log"` currently accepts `address` (single) + `event_signature` (topic-0). Schema could grow `addresses` (list) and `topics` (full topic-0..3 array) — I kept it small to match the example in docs/02. Happy to extend.

4. Boundary between supervisor and main. Event-loop logic is in main.rs today (`open_block_streams` / `open_log_streams` / `run_event_loop`). It would fit in `supervisor.rs` for symmetry; left in main to keep the supervisor module focused on per-module concerns. Easy to move.