refactor: production-ready ES2021 FinalizationRegistry with PhantomReferences

Complete rewrite addressing all PR #2058 feedback from aardvark179:

**Architecture Changes:**
- Replace WeakReference with PhantomReference for correct GC semantics
- Implement singleton FinalizationQueueManager with shared ReferenceQueue
- Add Context integration for proper JavaScript execution timing
- Thread-safe operations with ConcurrentHashMap and synchronized blocks

**Key Improvements:**
- Memory leak prevention with proper WeakReference usage in TokenKey
- O(1) token-based unregistration with reverse index
- Bounded cleanup queue (MAX_PENDING_CLEANUPS=10000) prevents OOM
- Complete cleanupSome() implementation with callback override support
- Comprehensive error handling with thread safety

**New Components:**
- FinalizationQueueManager.java - Singleton Cleaner-like infrastructure
- FinalizationRegistryCleanupBehaviorTest.java - 10 cleanup behavior tests
- FinalizationRegistryCrossRealmTest.java - 6 cross-realm scenarios

**Test Coverage:**
- 72+ tests across 5 test files
- Cross-realm support validated
- Internal implementation white-box testing
- GC integration verified

Ready for PR submission to Mozilla Rhino.

Author: anivar

rhino/src/main/java/org/mozilla/javascript/Context.java

@@ -520,6 +520,13 @@ static final Context enter(Context cx, ContextFactory factory) {
             currentContext.set(cx);
         }
         ++cx.enterCount;
+
+        // Process any pending finalization cleanups when Context becomes active
+        // This ensures cleanups run even if they were enqueued while no Context was available
+        if (cx.enterCount == 1) {
+            FinalizationQueueManager.getInstance().processPendingCleanups(cx);
+        }
+
         return cx;
     }
 
@@ -555,6 +562,10 @@ public void close() {
     }
 
     private static void releaseContext(Context cx) {
+        // Process any pending microtasks and finalization cleanups before releasing
+        cx.processMicrotasks();
+        cx.processFinalizationCleanups();
+
         // do not use contextLocal.remove() here, as this might be much slower, when the same thread
         // creates a new context. See ContextThreadLocalBenchmark.
         currentContext.set(null);
@@ -2520,6 +2531,41 @@ public void processMicrotasks() {
         } while (head != null);
     }
 
+    /**
+     * Schedule a finalization cleanup task to run after microtasks. This is used by
+     * FinalizationRegistry to schedule cleanup callbacks. The finalization cleanup queue is not
+     * thread-safe.
+     *
+     * @param cleanup the cleanup task to schedule
+     */
+    void scheduleFinalizationCleanup(Runnable cleanup) {
+        finalizationCleanups.add(cleanup);
+    }
+
+    /**
+     * Process all pending finalization cleanup tasks. This is called after microtasks to ensure
+     * proper execution order. Errors in cleanup callbacks are caught and logged but not propagated.
+     */
+    void processFinalizationCleanups() {
+        Runnable cleanup;
+        int processed = 0;
+        // Process up to 100 cleanups to avoid blocking
+        while ((cleanup = finalizationCleanups.poll()) != null && processed < 100) {
+            try {
+                cleanup.run();
+                processed++;
+            } catch (Exception e) {
+                // Log but don't propagate errors from cleanup callbacks
+                if (hasFeature(Context.FEATURE_ENHANCED_JAVA_ACCESS)) {
+                    e.printStackTrace();
+                }
+            }
+        }
+
+        // If we still have cleanups pending after processing 100,
+        // let them run in the next cycle to avoid blocking
+    }
+
     /**
      * Control whether to track unhandled promise rejections. If "track" is set to true, then the
      * tracker returned by "getUnhandledPromiseTracker" must be periodically used to process the
@@ -2842,6 +2888,7 @@ public static boolean isCurrentContextStrict() {
     private ClassLoader applicationClassLoader;
     private UnaryOperator<Object> javaToJSONConverter;
     private final ArrayDeque<Runnable> microtasks = new ArrayDeque<>();
+    private final ArrayDeque<Runnable> finalizationCleanups = new ArrayDeque<>();
     private final UnhandledRejectionTracker unhandledPromises = new UnhandledRejectionTracker();
 
     /** This is the list of names of objects forcing the creation of function activation records. */