Valid-Elixir macro frontend for generating RustQ Rust fragments.

defrust captures a normal Elixir function-shaped body plus its preceding @spec, lowers that quoted Elixir AST to Rust, and exposes generated Rust items through __rustq_items__/0 and __rustq_source__/0.

defrustmod is for RustQ-owned Rust module structure. Prefer its block form when RustQ is generating the Rust module and the nested functions. Do not use it as a hand-written alias for Rust modules/types that are owned by another generator or crate; those callers should derive/render their Rust paths at their own codegen boundary instead of pretending external Rust modules are Elixir modules.

Prefer @spec plus defrust for user-facing Rusty Elixir. Generated or external Rust paths should normally be expressed as ordinary remote types such as GeneratedOpts.OvalOpts.t(R.lifetime(:a)); use RustQ.Type markers such as R.ref/1, R.nif_result/1, R.unit/0, R.slice/1, and R.lifetime/1 only where Elixir typespecs need Rust-specific precision. quoted/2 is a low-level bridge for internal generators that already hold RustQ AST signature metadata; it is not the intended authoring surface.

Preferred Rusty-Elixir body forms are ordinary Elixir where possible:

• final :ok under NifResult<()> returns Ok(())
• name = expression lowers to Rust let name = expression
• method calls, field access, aliases, and Elixir tuples lower to their Rust equivalents
• plural alias calls such as Atoms.fill() lower to snake-case Rust module calls such as atoms::fill()
• ordinary Elixir macros are expanded before lowering, so reusable body fragments can use defmacro, quote, and unquote
• unwrap!(expression) is the explicit spelling for Rust expression?
• ref(expression) / mut_ref(expression) spell Rust borrows; deref(expression) spells Rust dereference
• Option branching should use Elixir case, for example case maybe do {:some, value} -> ...; :none -> ... end; do not introduce Rust-shaped if_let syntax at the authoring layer

Escape hatches such as raw_expr! remain low-level last resorts, not the normal way to reference project-owned Rust modules or types.