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/function.rs

@@ -353,7 +353,13 @@ pub fn expand(args: FunctionArgs, item: ItemFn) -> TokenStream {
     let output_nullable = analysis.nullable;
     let private = args.private;
 
-    let dispatch_body = build_dispatch(&item, &input_args, has_input, &input_type_ident);
+    let dispatch_body = build_dispatch(
+        &item,
+        &input_args,
+        has_input,
+        &input_type_ident,
+        analysis.returns_result,
+    );
 
     quote! {
         // Keep the user's original fn intact — the macro never rewrites the
@@ -454,8 +460,18 @@ fn build_dispatch(
     input_args: &[InputArg],
     has_input: bool,
     input_type_ident: &syn::Ident,
+    returns_result: bool,
 ) -> TokenStream {
     let inner = &item.sig.ident;
+    // When the user returns `Result<T, MizanError>`, lift Err out into the
+    // dispatch wrapper's outer Result so the HTTP/IPC adapter can surface
+    // it as the standard error envelope. When the user returns `T`,
+    // serialize directly — the substrate has no error path for them.
+    let unwrap_user_result = if returns_result {
+        quote! { ? }
+    } else {
+        TokenStream::new()
+    };
     if has_input {
         let arg_names: Vec<_> = input_args.iter().map(|a| &a.ident).collect();
         quote! {
@@ -467,7 +483,7 @@ fn build_dispatch(
             let result = #inner(
                 &req,
                 #( validated.#arg_names ),*
-            ).await;
+            ).await #unwrap_user_result;
             ::mizan_core::__priv::serde_json::to_value(&result)
                 .map_err(|e| ::mizan_core::MizanError::InternalError(
                     format!("output serialization failed: {e}"),
@@ -476,7 +492,7 @@ fn build_dispatch(
     } else {
         quote! {
             let _ = args;
-            let result = #inner(&req).await;
+            let result = #inner(&req).await #unwrap_user_result;
             ::mizan_core::__priv::serde_json::to_value(&result)
                 .map_err(|e| ::mizan_core::MizanError::InternalError(
                     format!("output serialization failed: {e}"),