Pin refinement CCs to fix SEGV

We carry 9e5ef24 ("Reapply \"Fix check in cc_is_active\"") and
b6e3272 ("Reapply \"Simplify iseq mark_and_move CC handling\""),
which make refinement CCs actually live and movable, but not upstream
master's 8eab317 ("Convert cc_refinement_table into TypedData
object"), which replaced the address-keyed cc_refinement_table with an
array of declarative weak references.

With the address-keyed table, compaction relocating a refinement CC
rewrites the set entry's key but leaves it filed under the hash of the
old address, so rb_vm_delete_cc_refinement() can no longer find it when
the CC is freed and the table is left pointing at a recycled slot. The
next using/refine walks that entry: in debug builds it fails
"vm_method.c:664: invalidate_cc_refinement:vm_cc_refinement_p(cc)"
(seen in test-all as TestRefinement#test_refine_mutual_recursion),
otherwise it silently writes Qundef into an unrelated live object.

Pin them like we already do for method entries that are keys of the
overloaded_cme table, and add a regression test that reproduces the
assertion 100% of the time without this change.

Author: rwstauner

imemo.c

@@ -379,6 +379,12 @@ rb_imemo_mark_and_move(VALUE obj, bool reference_updating)
             if ((vm_cc_super_p(cc) || vm_cc_refinement_p(cc))) {
                 rb_gc_mark_movable((VALUE)cc->cme_);
             }
+
+            if (vm_cc_refinement_p(cc)) {
+                // it is a key of the "cc_refinement" table, which looks up
+                // entries by address, so it should be pinned.
+                rb_gc_mark(obj);
+            }
         }
 
         break;

test/ruby/test_gc_compact.rb

@@ -161,6 +161,48 @@ def walk_ast ast
     end;
   end
 
+  def test_refinement_callcaches_are_not_moved
+    assert_separately([], "#{<<~"begin;"}\n#{<<~"end;"}", timeout: 60)
+    begin;
+      module RefinementForCompaction
+        refine String do
+          def refined_method; :refined; end
+        end
+      end
+      using RefinementForCompaction
+
+      objects = []
+      10.times do
+        procs = 200.times.map { eval("proc { 'str'.refined_method }") }
+        procs.each(&:call)
+
+        # Refinement call caches are registered in a VM wide table which looks
+        # up entries by address, so they must not be moved.
+        GC.verify_compaction_references(expand_heap: false, toward: :empty)
+
+        procs = nil
+        GC.start
+
+        # Reuse the slots of the collected refinement call caches.
+        500.times do
+          klass = Class.new { def foo; end }
+          obj = klass.new
+          3.times { obj.foo }
+          objects << obj
+        end
+      end
+
+      # Invalidates every registered refinement call cache.
+      module RefinementForCompaction
+        refine String do
+          def other_refined_method; :refined; end
+        end
+      end
+
+      assert_equal(:refined, "str".refined_method)
+    end;
+  end
+
   def test_compact_count
     count = GC.stat(:compact_count)
     GC.compact