[STUBGEN][RUST] Add the Rust backend with opaque object bindings

[Seven-Streams]

Summary

Register --target rust in tvm-ffi-stubgen. Every reflected object becomes an opaque Rust binding: a #[repr(C)] struct that embeds only its parent, a reference wrapper, read-only Deref, impl_object_upcast! along the ancestor chain, and one accessor per reflected field that reads through the C ABI getter (FieldGetter). The object's bytes are never reproduced, so the binding is correct for every registered type. Three directives (field, nullable, enum) shape the accessor types. A CMake STUB_TARGET option and an example project with its generated module checked in round it out.

Rebased on main after #736; depends on nothing else.

Motivation

This is the first Rust step of the series that replaces #609 (after the layout classifier in #730 and the directive channel in #736). Starting with the opaque form keeps "never generate a wrong layout" true from the first Rust PR. The follow-ups attach the classifier and upgrade the types whose layout the registry can prove to full field mirrors, then add allocators.

The opaque form is not a stopgap. Polymorphic types, types with unreflected bytes, and types the registry has no layout for stay opaque forever, and reading their fields through the reflected getter is the only correct option. It is exactly what tvm-rust-ext hand-writes today for IterVar, Axis, TileLayout, BufferRegion, SourceName, and Source; this PR generates that shape from directives alone.

Changes

• python/tvm_ffi/stub/rust_generator/ (new)
  • consts.py: FFI-origin to Rust-type map, ffi.* to crate-root rewrite, declared directive names, keyword table.
  • utils.py: RustUse / RustImports (per-file use collector plus directives), render_rust_type (returns None where the crate has no mirror), rust_ident.
  • directives.py: grammar of field: K.f -> T, nullable: K.f, enum: K.f -> Name(i32) { A=0, ... }; malformed payloads are rejected with the line number.
  • codegen.py: _ObjectRenderer (module-tree name resolution, accessors, the #[repr(transparent)] enum newtype with TryFrom<i64>, Deref, upcasts), plus the import section, --init scaffold and pub mod stitching carried over from [FEAT][STUBGEN] Add Rust code generation backend #609.
  • generator.py: the Generator protocol adapter, declaring {import-object, field, nullable, enum}.
• stub/generator.py: registers "rust".
• cmake/Utils/Library.cmake: STUB_TARGET, passed as --target.
• examples/rust_stubgen/: a polymorphic C++ object with two registered global functions, a Rust program that constructs it through the FFI and reads it through the generated accessors, and the generated mod.rs with an enum directive.

Decisions worth a look:

• A field without a Rust mirror (Union, Dict, List, tuple, void*, an unmapped bare origin) gets an accessor returning Any. Nothing is skipped; there is no UnsupportedTypeError.
• A builtin ffi.* parent has no generated <Leaf>Obj, so such a type embeds the object header and upcasts only to generated ancestors.
• A use whose leaf is already taken is spelled in full at the use site instead of failing.
• No allocator is generated: construction goes through the registered global functions, as in the example.

Not carried over from #609: the builder, DerefMut, same_as / downcast, method generation, the offset warnings, and every Rust runtime change.

Testing

tests/python/test_stubgen_rust.py (31 cases): use modelling and collisions; value-type rendering including origins without a mirror; the three directive grammars and their rejections; goldens for a root object (header base, Any fallback, r#type), same-module and cross-module derived objects, a builtin-parent object, and the hand-written IterVar of tvm-rust-ext reproduced from directives; import section, --init scaffold and module-tree stitching; _stage_3 over a registered type with an enum directive; the CLI in --init mode over the testing. prefix, run twice to confirm idempotence. Full Python suite passes on the rebased branch.

The example builds end to end: cmake --build regenerates rust/src/generated/rust_stubgen/mod.rs, and cargo run prints a=1 b=2 kind=PairKind(1) and sum=3 against the C++ library.