fix(printer): recover non-builtin static/vtable alloc typing (#131)

### Summary
- In `src/printer.rs`, `collect_alloc` no longer panics on
non-`builtin_deref` `GlobalAlloc::Static` / `GlobalAlloc::VTable` paths.
- It now attempts `get_prov_ty(ty, offset)` first, and falls back to
opaque `Ty::to_val(0)` when recovery is not possible.
- Existing behavior for direct `builtin_deref` pointer/reference paths
is unchanged.
- Added a regression test using the existing integration golden
framework:
  - `tests/integration/programs/static-vtable-nonbuiltin-deref.rs`
-
`tests/integration/programs/static-vtable-nonbuiltin-deref.smir.json.expected`
- minimal normalization update in
`tests/integration/normalise-filter.jq` (strip unstable `def_id`).

### Context
This PR was split from
[stable-mir-json#129](#129)
so `#129` can stay focused on closure type-table metadata.

The failure mode here was assert-based panic in pre-fix code when a
provenance edge reached `Static`/`VTable` through a non-`builtin_deref`
container type.

### Testing
Automated (local):
- RED (pre-fix baseline on `origin/master`):
- `make integration-test
TESTS=tests/integration/programs/static-vtable-nonbuiltin-deref.rs`
- Result: fails with `Allocated pointer is not a built-in pointer type`
panic at `src/printer.rs:789`.
- GREEN (this branch):
- `make integration-test
TESTS=tests/integration/programs/static-vtable-nonbuiltin-deref.rs` ✅
- `make integration-test TESTS=tests/integration/programs/assert_eq.rs`
✅
  - `cargo +nightly-2024-11-29 fmt --check` ✅
  - `cargo +nightly-2024-11-29 clippy -- -Dwarnings` ✅

GitHub checks:
- New run for head `11180ce` is in progress.

Author: Stevengre

src/printer/mir_visitor.rs

@@ -265,10 +265,61 @@ fn collect_alloc(
                     .insert(val, (opaque_placeholder_ty(), global_alloc.clone()));
             }
         }
-        GlobalAlloc::Static(_) | GlobalAlloc::VTable(_, _) => {
-            val_collector
-                .visited_allocs
-                .insert(val, (ty, global_alloc.clone()));
+        GlobalAlloc::Static(_) => {
+            // Keep builtin-deref behavior; recover only non-builtin-deref cases.
+            if kind.clone().builtin_deref(true).is_none() {
+                let prov_ty = get_prov_ty(ty, &offset);
+                debug_log_println!(
+                    "DEBUG: GlobalAlloc::Static with non-builtin-deref type; alloc_id={:?}, ty={:?}, offset={}, kind={:?}, recovered_prov_ty={:?}",
+                    val,
+                    ty,
+                    offset,
+                    kind,
+                    prov_ty
+                );
+                if let Some(p_ty) = prov_ty {
+                    val_collector
+                        .visited_allocs
+                        .insert(val, (p_ty, global_alloc.clone()));
+                } else {
+                    // Recovery failed: do not treat outer container `ty` as pointee.
+                    val_collector
+                        .visited_allocs
+                        .insert(val, (opaque_placeholder_ty(), global_alloc.clone()));
+                }
+            } else {
+                val_collector
+                    .visited_allocs
+                    .insert(val, (ty, global_alloc.clone()));
+            }
+        }
+        GlobalAlloc::VTable(_, _) => {
+            // Same policy as Static: keep builtin-deref, recover non-builtin-deref.
+            if kind.clone().builtin_deref(true).is_none() {
+                let prov_ty = get_prov_ty(ty, &offset);
+                debug_log_println!(
+                    "DEBUG: GlobalAlloc::VTable with non-builtin-deref type; alloc_id={:?}, ty={:?}, offset={}, kind={:?}, recovered_prov_ty={:?}",
+                    val,
+                    ty,
+                    offset,
+                    kind,
+                    prov_ty
+                );
+                if let Some(p_ty) = prov_ty {
+                    val_collector
+                        .visited_allocs
+                        .insert(val, (p_ty, global_alloc.clone()));
+                } else {
+                    // Unknown is safer than wrong pointee type.
+                    val_collector
+                        .visited_allocs
+                        .insert(val, (opaque_placeholder_ty(), global_alloc.clone()));
+                }
+            } else {
+                val_collector
+                    .visited_allocs
+                    .insert(val, (ty, global_alloc.clone()));
+            }
         }
         GlobalAlloc::Function(_) => {
             if !kind.is_fn_ptr() {

tests/integration/normalise-filter.jq

@@ -29,3 +29,5 @@
     ( .types | map(select(.[0].FunType) | sort) )
   ] | flatten(1) )
 }
+# drop unstable compiler-internal ids that are unrelated to this regression
+| walk(if type == "object" then del(.def_id) else . end)

tests/integration/programs/static-vtable-nonbuiltin-deref.rs

@@ -0,0 +1,9 @@
+use std::fmt::Debug;
+
+static S: u8 = 7;
+const OBJS: [&'static dyn Debug; 1] = [&S as &dyn Debug];
+
+fn main() {
+    // Keep trait-object constant usage so both Static and VTable allocs are emitted.
+    std::hint::black_box(OBJS[0]);
+}