ZJIT: constant fold bitwise OR (|) operations (ruby#16235)

Continuation of ruby#16226.

### Considerations
- The OR (`|`) operation in Rust has the same behavior as in Ruby (it compiles to a assembly `or` instruction: https://godbolt.org/z/5McGzj783);
- There are no risk of overflows;
- In the test, I added the result of the interpreter in an assertion based on feedback of my last PR.

Author: tomascco

zjit/src/hir.rs

@@ -4640,6 +4640,12 @@ impl Function {
                             _ => None,
                         })
                     }
+                    Insn::FixnumOr { left, right, .. } => {
+                        self.fold_fixnum_bop(insn_id, left, right, |l, r| match (l, r) {
+                            (Some(l), Some(r)) => Some(l | r),
+                            _ => None,
+                        })
+                    }
                     Insn::FixnumEq { left, right, .. } => {
                         self.fold_fixnum_pred(insn_id, left, right, |l, r| match (l, r) {
                             (Some(l), Some(r)) => Some(l == r),

zjit/src/hir/opt_tests.rs

@@ -562,6 +562,96 @@ mod hir_opt_tests {
         ");
     }
 
+    #[test]
+    fn test_fold_fixnum_or() {
+        eval("
+            def test
+              4 | 1
+            end
+        ");
+
+        assert_snapshot!(inspect("test"), @"5");
+        assert_snapshot!(hir_string("test"), @"
+        fn test@<compiled>:3:
+        bb1():
+          EntryPoint interpreter
+          v1:BasicObject = LoadSelf
+          Jump bb3(v1)
+        bb2():
+          EntryPoint JIT(0)
+          v4:BasicObject = LoadArg :self@0
+          Jump bb3(v4)
+        bb3(v6:BasicObject):
+          v10:Fixnum[4] = Const Value(4)
+          v12:Fixnum[1] = Const Value(1)
+          PatchPoint MethodRedefined(Integer@0x1000, |@0x1008, cme:0x1010)
+          v25:Fixnum[5] = Const Value(5)
+          IncrCounter inline_cfunc_optimized_send_count
+          CheckInterrupts
+          Return v25
+        ");
+    }
+
+    #[test]
+    fn test_fold_fixnum_or_with_negative_self() {
+        eval("
+            def test
+              -4 | 1
+            end
+        ");
+
+        assert_snapshot!(inspect("test"), @"-3");
+        assert_snapshot!(hir_string("test"), @"
+        fn test@<compiled>:3:
+        bb1():
+          EntryPoint interpreter
+          v1:BasicObject = LoadSelf
+          Jump bb3(v1)
+        bb2():
+          EntryPoint JIT(0)
+          v4:BasicObject = LoadArg :self@0
+          Jump bb3(v4)
+        bb3(v6:BasicObject):
+          v10:Fixnum[-4] = Const Value(-4)
+          v12:Fixnum[1] = Const Value(1)
+          PatchPoint MethodRedefined(Integer@0x1000, |@0x1008, cme:0x1010)
+          v25:Fixnum[-3] = Const Value(-3)
+          IncrCounter inline_cfunc_optimized_send_count
+          CheckInterrupts
+          Return v25
+        ");
+    }
+
+    #[test]
+    fn test_fold_fixnum_or_with_negative_other() {
+        eval("
+            def test
+              4 | -1
+            end
+        ");
+
+        assert_snapshot!(inspect("test"), @"-1");
+        assert_snapshot!(hir_string("test"), @"
+        fn test@<compiled>:3:
+        bb1():
+          EntryPoint interpreter
+          v1:BasicObject = LoadSelf
+          Jump bb3(v1)
+        bb2():
+          EntryPoint JIT(0)
+          v4:BasicObject = LoadArg :self@0
+          Jump bb3(v4)
+        bb3(v6:BasicObject):
+          v10:Fixnum[4] = Const Value(4)
+          v12:Fixnum[-1] = Const Value(-1)
+          PatchPoint MethodRedefined(Integer@0x1000, |@0x1008, cme:0x1010)
+          v25:Fixnum[-1] = Const Value(-1)
+          IncrCounter inline_cfunc_optimized_send_count
+          CheckInterrupts
+          Return v25
+        ");
+    }
+
     #[test]
     fn test_fold_fixnum_less() {
         eval("