mizan-tauri + Pydantic-aware codegen: Tauri-as-Mizan-backend substrate

Tauri now joins FastAPI/Django/axum as a first-class Mizan backend. The
React frontend calls Mizan-registered functions through Tauri's IPC
with the same {result, invalidate, merge} envelope the HTTP path uses;
the schema flows Pydantic → decoru → Rust → KDL → TS in one
mizan-generate invocation.

New packages:
* backends/mizan-tauri — Tauri plugin exposing a single `mizan_invoke`
  command that routes through mizan-core's FUNCTIONS / CONTEXTS
  registries. No per-function tauri::command; the linkme slice IS the
  dispatch table.
* frontends/mizan-tauri-transport — TS package exporting
  tauriTransport() that wraps invoke('plugin:mizan|mizan_invoke', ...)
  and re-shapes errors into MizanError. Pairs with mizan-tauri.

@mizan/base — pluggable transport:
* Adds MizanTransport interface + transport config field.
* Existing fetch-based body factored into httpTransport() (default).
* mizanCall/mizanFetch delegate to config.transport; merge/invalidate
  side-effects stay in the kernel (transport-agnostic).
* Consumers swap via configure({ transport: tauriTransport() }).

mizan-codegen — Rust source + Pydantic pre-step:
* [source.rust] runs a Cargo bin (cargo run --bin <name>) and parses
  KDL from stdout. The bin uses mizan_core::build_ir() after
  force-linking the consumer's #[derive(Mizan)] / #[mizan::client]
  registrations.
* [source.rust.pydantic] is an optional pre-step that pipes an
  embedded Python bridge (scripts/run_decoru.py) to python and writes
  decoru-emitted Rust types into the consumer crate. The bridge
  auto-discovers BaseModel subclasses AND Enum subclasses
  (last-variant-is-default convention so decoru's impl Default keeps
  compiling against enum-typed fields without explicit Pydantic
  defaults).
* Pure-Rust usage stays intact — omit pydantic block and write Rust
  types by hand.

mizan-macros:
* #[mizan::client] now supports Result<T, MizanError> returns. The
  dispatch wrapper `?`-unwraps the user fn so server-side errors
  surface as the protocol's standard {code, message, details?}
  envelope; T-returning functions stay unchanged.
* #[derive(Mizan)] strips the r# raw-identifier prefix and honors
  field-level #[serde(rename = "...")] when emitting IR field names.
  Matches serde's wire shape — fixes IR-vs-JSON drift for Rust-keyword
  fields (e.g. `r#type` → `type`).

react.tsx template:
* Conditionally emits context-related imports / useContextSubscription
  helper based on has_global || !named_contexts.is_empty(). Consumers
  without contexts (mutation/RPC-only apps like claude-manage) no
  longer get dead imports that trip noUnusedLocals.

Verified end-to-end: cargo build clean across mizan-tauri,
mizan-codegen, AFI rust_app; AFI three-way KDL parity tests pass;
claude-manage migration drives the full stack (Pydantic schema →
generated TS api → Tauri-IPC transport → mizan-core dispatch).

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

cores/mizan-rust-macros/src/shape.rs

@@ -16,20 +16,32 @@ pub struct ReturnAnalysis {
     pub is_vec: bool,
     /// When `is_vec`, this is the element type `T`.
     pub vec_inner: Option<Type>,
+    /// True when the user's return type is `Result<T, MizanError>` — the
+    /// dispatch wrapper emits `?` so user-side errors bubble out as
+    /// `MizanError` instead of being serialized into the success payload.
+    /// The IR sees only the `T` side; the error variant is the substrate's
+    /// invariant, not part of the output shape.
+    pub returns_result: bool,
 }
 
 pub fn analyze_return(ty: &Type) -> ReturnAnalysis {
-    let (inner, nullable) = if let Some(t) = unwrap_option(ty) {
-        (t, true)
+    let (effective, returns_result) = if let Some(ok) = unwrap_result_ok(ty) {
+        (ok, true)
     } else {
         (ty.clone(), false)
     };
+    let (inner, nullable) = if let Some(t) = unwrap_option(&effective) {
+        (t, true)
+    } else {
+        (effective, false)
+    };
     if let Some(elem) = unwrap_vec(&inner) {
         ReturnAnalysis {
             inner: inner.clone(),
             nullable,
             is_vec: true,
             vec_inner: Some(elem),
+            returns_result,
         }
     } else {
         ReturnAnalysis {
@@ -37,10 +49,27 @@ pub fn analyze_return(ty: &Type) -> ReturnAnalysis {
             nullable,
             is_vec: false,
             vec_inner: None,
+            returns_result,
         }
     }
 }
 
+/// If `ty` is `Result<T, E>`, return `T`. Otherwise None. The substrate
+/// only honors `Result<T, MizanError>`; the macro doesn't try to verify
+/// `E` here — it lets rustc raise the type-mismatch at the `?` site if
+/// the consumer used a non-MizanError variant.
+pub fn unwrap_result_ok(ty: &Type) -> Option<Type> {
+    let path = match ty {
+        Type::Path(TypePath { qself: None, path }) => path,
+        _ => return None,
+    };
+    let last = path.segments.last()?;
+    if last.ident != "Result" {
+        return None;
+    }
+    extract_single_generic(&last.arguments)
+}
+
 /// Emit a `TypeShape` const-expression for `ty`. Used inside `#[derive(Mizan)]`
 /// when constructing the struct field shapes.
 pub fn type_shape_expr(ty: &Type) -> TokenStream {