## Summary

`GuardType` narrows only its result id, not the original input. 
A later guard on the same input therefore looks unfoldable to `fold_constants` even though the side-exit semantics already prove the narrower type.
Canonicalize rewrites later uses to the most recent `Guard*` result, making the redundant guard foldable.
For example, in this CFG-join shape:

 ```ruby
  def test(n, cond)                                                                                                           
    if cond   
      a = n + 1
    else                                                                                                                      
      a = n + 2
    end                                                                                                                       
    n + a   # `n` gets a redundant Fixnum guard here
  end
 ```

This PR adds a block-local HIR `canonicalize` pass that walks each block in RPO and rewrites every operand through union-find plus a per-block `rewrite_map` keyed on the most recent `Guard*` for that value. 
After canonicalization, `infer_types` can narrow merge-block parameter types and `fold_constants` can then drop the redundant guards in both shapes above.

Inspired by Cranelift's canonicalize https://cfallin.org/blog/2026/04/09/aegraph/

Fixes: https://github.com/Shopify/ruby/issues/978

## Benchmarks

Bench (arm64 linux devcontainer, ruby/ruby-bench, warmup=10 bench=20)

```
  Throughput              master/staged
    lobsters              1.021 (+2.1%, within ±3-6% noise)
    railsbench            1.012 (+1.2%, within ±3-4% noise)

  --zjit-stats            lobsters / railsbench
    code_region_bytes     -1.1%   / -1.0%   (redundant CFG-join guards still removed)
    guard_type_count      -29.4%  / +30.1%  (railsbench likely single-run noise) ⚠
    compile_hir_time      +14.6%  / +13.7%  (canonicalize_time: 67ms / 31ms)
    invalidation_time      ±0%    /  ±0%
```

Branch arms (IfTrue, IfFalse, Jump) update target block param types
but were not flagging the fixpoint loop's `changed` bit. With a pure
shuffle block (no non-branch insns to drive `changed` via their
own infer_type), the loop could exit while param types were still
widening. Now each branch arm sets `changed = true` whenever the
union actually grew a param's type.

Add an HIR build test: a self-loop with a 4-cycle param rotation
must reach the full union of all four input types at every param,
which would previously fall short by one type even with parallel
phi semantics.

In infer_types, snapshot the types of all branch arguments before
writing to any target block param. Previously, when a self-loop's
branch args referenced the target's own params (e.g. a phi swap),
updating params sequentially could observe values updated earlier
in the same loop iteration.

We changed how AnyToString worked and no longer need this instruction.

This is because `make test-bundler-parallel` command, which runs
successfully via turbo_tests, does not have `--disable-gems` option
specified.

`--disable-gems` is currently set in `RUN_OPTS`. Removing it would
affect not only test-bundler but the entire test suite, so I have
configured it specifically for this command instead.

This patch will fix an error in `./spec/bundler/bundler/cli_common_spec.rb`
when executing `make test-bundler`.

Co-authored-by: Sutou Kouhei <kou@clear-code.com>

The `FiberError` class can be used in `fiber_pool_initialize` through
`fiber_pool_expand` but `FiberError` was defined after
`fiber_pool_initialize` in `Init_Cont`. This commit moves the definition
of `FiberError` before `fiber_pool_initialize` to ensure that
`FiberError` is defined before any possible usage.

https://github.com/ruby/json/commit/1d32bd4596

This couldn't possibly lead to a crash unless you'd mess
with GC.stress or `send(:initialize)` on an old object.

But for correctness, it should be there.

https://github.com/ruby/json/commit/ab6972d797