fix(ty_visitor): drop global panic hook swap, keep catch_unwind

TIL (thanks Copilot!), the previous approach temporarily replaced the
process-wide panic hook with a no-op to suppress backtraces from caught
layout panics. Turns out that's a thread-safety footgun: rustc's own
worker threads could panic while the no-op hook is installed, silently
swallowing unrelated diagnostics. The hook swap was also racy with
anything else that calls set_hook concurrently.

catch_unwind is what actually keeps the process alive; the hook swap was
purely cosmetic (suppressing stderr noise). Dropped it entirely and
accepted the default backtrace output for caught panics. The end-of-run
LayoutPanic summary still reports everything it did before. My research
surfaced a way to suppress the stderr noise that I decided was too much
for a little noise, but I'm including here for completeness.

Set teh hook once at startup (not per-call) to a hook that checks a
thread-local flag:

```rust
thread_local! {
  static SUPPRESS_PANIC_OUTPUT: Cell<bool> = const { Cell::new(false) };
}

// Called once, e.g. in driver setup:
std::panic::set_hook(Box::new(|info| {
  SUPPRESS_PANIC_OUTPUT.with(|flag| {
      if !flag.get() {
          eprintln!("{info}");
      }
  });
}));

// Then in try_layout_shape, just toggle the flag:
SUPPRESS_PANIC_OUTPUT.with(|f| f.set(true));
let result = catch_unwind(AssertUnwindSafe(|| ty.layout()...));
SUPPRESS_PANIC_OUTPUT.with(|f| f.set(false));

This is thread-safe (thread-local, not global), no race conditions, no
risk of swallowing other threads' panics, and our collected LayoutPanic
report at teh end works exactly as before.

Author: cds-amal

src/printer/ty_visitor.rs

@@ -13,7 +13,7 @@ use crate::compat::stable_mir;
 
 use std::collections::{HashMap, HashSet};
 use std::ops::ControlFlow;
-use std::panic::{catch_unwind, set_hook, take_hook, AssertUnwindSafe};
+use std::panic::{catch_unwind, AssertUnwindSafe};
 
 use stable_mir::mir::mono::Instance;
 use stable_mir::ty::{RigidTy, TyKind};
@@ -37,12 +37,13 @@ pub(super) struct LayoutPanic {
 fn try_layout_shape(
     ty: &stable_mir::ty::Ty,
 ) -> Result<Option<stable_mir::abi::LayoutShape>, String> {
-    // Temporarily suppress the default panic hook so caught panics don't
-    // spray backtraces to stderr; we report them in our own summary.
-    let prev_hook = take_hook();
-    set_hook(Box::new(|_| {}));
+    // catch_unwind keeps the process alive when rustc's layout engine panics
+    // (e.g. on certain `dyn Trait` types). The default panic hook will still
+    // print a backtrace to stderr for each caught panic; that's noisy but
+    // harmless, and avoids the thread-safety issues of swapping the global
+    // hook per-call. We collect the messages and report them in our own
+    // summary at the end.
     let result = catch_unwind(AssertUnwindSafe(|| ty.layout().ok().map(|l| l.shape())));
-    set_hook(prev_hook);
 
     match result {
         Ok(shape) => Ok(shape),