[Feat][Rust] Add native structural_map and structural_mutate

[tlopex]

This PR adds Rust-native structural transformation support as a counterpart to the structural mapping APIs proposed in #649, building on the Rust structural_visit and structural_walk infrastructure introduced in #693.

The structural transformation algorithm remains in Rust: traversal order, recursion, typed dispatch, definition-region propagation, memoization, and identity remapping are all controlled by the Rust implementation.

For runtime-owned Map and Dict storage, this PR introduces a narrow, pointer-only C ABI. The runtime performs only storage-specific operations such as iteration, uniqueness checks, shallow copying, and value replacement. Each child value is synchronously returned to Rust for structural recursion and dispatch.

Rust APIs

This PR provides:

• structural_map with pre-order and post-order callbacks.
• A low-level StructuralMutator trait for user-controlled recursion.
• Typed closures, ordered callback tuples, and #[dispatch(map)].
• Definition-region propagation.
• DAG and FreeVar identity remapping.
• Structural error context.
• Native Array, List, Map, Dict, and reflected-object mutation.
• Copy-on-write and optional in-place container reuse.
• Map and Dict keys remain structural anchors and are not mapped.

Ownership and mutation semantics

The root is consumed so Rust ownership and the runtime strong-reference count
determine whether a container may be reused.

• Uniquely owned Array, List, Map, and Dict objects may be updated in place.
• Passing a shared root, such as root.clone(), selects copy-on-write behavior.
• A shared immutable Map is shallow-copied lazily when its first changed value
  is found.
• A shared mutable Dict is shallow-copied before the first callback, providing
  a stable snapshot if a callback re-enters and mutates an alias of the source
  Dict.
• If no structural value changes, the original object identity is returned.
• If an in-place transformation fails after earlier values were replaced,
  completed prefix replacements are retained.
• Partially produced FFI getter, setter, and Map callback results are released
  on error paths.
• Rust panics are caught at the C ABI boundary and resumed only after runtime
  RAII cleanup has completed.

Stable Map and Dict runtime boundary

This PR adds two additive C ABI functions:

• TVMFFIMapIterate
• TVMFFIMapMutateValues

These functions keep the private MapBaseObj small/dense hash-table layout, iteration links, allocator, and deleter inside the runtime that owns them.

Rust no longer mirrors or reads the private C++ Map/Dict storage layout. TVMFFIAny values cross this boundary only through pointers; no C++ Any or AnyView class is passed or returned by value.

The callbacks are synchronous, serial, run on the calling thread, and are not retained by the runtime. Structural recursion and nested transformation remain in Rust.

No object layout or existing C ABI is changed. The two new C symbols are additive. Because Rust calls these symbols directly, the Rust crate and runtime must come from compatible versions; the previous old-runtime reconstruction fallback is removed.

Runtime-registered mutation hooks

Following the boundary established by the Rust structural-visit implementation in #693, this PR does not invoke runtime-registered __s_mutate__ or __s_maybe_inplace_mutate__ hooks.

A non-container type defining either hook is rejected with an actionable error instead of silently replacing its custom mutation semantics with reflected traversal. Its behavior can be implemented explicitly through the RustStructuralMutator trait.

This PR does not construct or mirror the C++ StructuralMutatorObj ABI. Supporting runtime-registered mutation hooks and allowing those hooks to re-enter a Rust mutator requires a separate interoperability layer and remains
outside this PR's scope.