ZJIT: Eliminate GuardType on frozen objects

When GuardType operates on a value that is a known frozen object (from a
constant), we can check at compile time if the object's type matches the
guard. Since frozen objects cannot change their class, the runtime guard
becomes unnecessary.

This optimization eliminates redundant type guards when accessing methods
on frozen constant objects, complementing the LoadField folding for ivar
reads.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: tobi

zjit/src/hir.rs

@@ -3677,11 +3677,24 @@ impl Function {
             let mut new_insns = vec![];
             for insn_id in old_insns {
                 let replacement_id = match self.find(insn_id) {
-                    Insn::GuardType { val, guard_type, .. } if self.is_a(val, guard_type) => {
-                        self.make_equal_to(insn_id, val);
-                        // Don't bother re-inferring the type of val; we already know it.
-                        continue;
+                    Insn::GuardType { val, guard_type, .. } => {
+                        // If we already know the type matches, eliminate the guard
+                        if self.is_a(val, guard_type) {
+                            self.make_equal_to(insn_id, val);
+                            continue;
+                        }
+                        // If GuardType is on a frozen object, we can check at compile time if the
+                        // object's type matches the guard. Frozen objects can't change class.
+                        let val_type = self.type_of(val);
+                        if let Some(obj) = val_type.ruby_object() {
+                            if obj.is_frozen() && Type::from_value(obj).is_subtype(guard_type) {
+                                self.make_equal_to(insn_id, val);
+                                continue;
+                            }
+                        }
+                        insn_id
                     }
+
                     Insn::LoadField { recv, offset, return_type, .. } if return_type.is_subtype(types::BasicObject) &&
                             u32::try_from(offset).is_ok() => {
                         let offset = (offset as u32).to_usize();