Rust Implementation of Apache Burr

**Is your feature request related to a problem? Please describe.**

I’d like to use Burr’s state-machine / action-graph approach in environments where Rust is the primary deployment/runtime (e.g., Rust microservices, single-binary distribution, memory-safety requirements, low-latency workloads, WASM targets, etc.).

Currently this means either running Burr as a separate Python service, embedding Python, or re-implementing similar functionality ad-hoc, each of which adds operational complexity and makes it harder to standardize on Burr as a core orchestration primitive across a Rust-heavy stack.

**Describe the solution you'd like**

I’d like to propose (and happily help implement) an officially supported or officially endorsed Rust implementation of Burr with the goal of full functional parity with the existing Python implementation, including:

* **Core runtime parity:** actions, transitions, state semantics, sync/async execution, parallelism features, hooks, typing system behavior, etc.
* **Persistence & tracking parity:** same data model and on-disk formats where applicable, so recorded runs are comparable/portable.
* **Telemetry/observability parity:** compatible tracing/metrics behavior (and the same conceptual execution events).
* **Tracking server + UI parity:** ideally, the existing UI can be used unchanged by matching the server API contract.
* **CLI parity:** equivalent commands/subcommands and behavior, or a clearly documented mapping.

Proposed Implementation approach:

* Define the spec as golden/characterization tests derived from the reference implementation (recorded runs + normalized outputs).
* Develop the test suite with a complete Rust project skeleton first.
* Develop subsystem-by-subsystem until all goldens pass and expanding coverage until parity is reached.

Questions for maintainers:

* Would this be welcome as an official multi-language implementation or preferred as a community project first?
* If official, should it live in this repo (subdir/workspace) or in a separate repo?

**Describe alternatives you've considered**

* **Rust wrapper around Python Burr** (PyO3 / embedding Python) to reuse existing behavior but with Rust entry-points.
* **Running Burr as a separate Python service** and integrating over HTTP/IPC from Rust (keeps Burr unchanged, but adds runtime/ops overhead).
* **Partial Rust port** (core runtime only) while keeping the existing tracking server/UI and/or persistence layer in Python.
* **Implementing only server/API compatibility** in Rust while leaving runtime execution to Python (or vice versa).
* Using other Rust state-machine/workflow crates instead of Burr (but that forfeits Burr’s model, tooling, and existing ecosystem).