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>

protocol/mizan-codegen/templates/react/react.tsx.j2

@@ -2,30 +2,38 @@
 
 // AUTO-GENERATED by mizan — do not edit
 
+{% set has_contexts = has_global || !named_contexts.is_empty() -%}
 import {
+    {% if has_contexts -%}
     createContext,
+    {% endif -%}
     useCallback,
+    {% if has_contexts -%}
     useContext,
     useEffect,
+    {% endif -%}
     useRef,
     useState,
+    {% if has_contexts -%}
     useSyncExternalStore,
+    {% endif -%}
     type ReactNode,
 } from 'react'
 import {
     configure,
-    initSession,
     mizanCall,
     mizanFetch,
-    MizanError,
+    {% if has_contexts -%}
     registerContext,
     type ContextState,
+    {% endif -%}
 } from '@mizan/base'
 
 {% if !stage1_imports.is_empty() -%}
 import { {{ stage1_imports|join(", ") }} } from './index'
 
 {% endif -%}
+{% if has_contexts -%}
 // Internal — runs inside a Provider, registers with the kernel exactly once.
 function useContextSubscription<T>(
     name: string,
@@ -46,6 +54,7 @@ function useContextSubscription<T>(
 
     return useSyncExternalStore(handle.subscribe, handle.getState, handle.getState)
 }
+{% endif %}
 
 // Internal — wraps an imperative call() with isPending / error state.
 interface MutationHook<TArgs, TResult> {