LibGC: Implement incremental garbage collection

Convert collector to run incrementally using tricolor marking
and a hybrid of Yuasa (SATB, deletion) and Dijkstra (insertion)
write barriers that shade both old and new targets gray.

Marking and sweeping budgets specified in cells, and blocks
respectively. Budgets are currently arbitrary but can be tuned
with an ini file.

This code is more than proof-of-concept but unrefined.

Author: marcbutler

Libraries/LibGC/Cell.h

@@ -38,6 +38,12 @@ public:                                            \
     }                                              \
     friend class GC::Heap;
 
+enum class Color : u8 {
+    White, // Not yet reached — will be reclaimed if still white at sweep time.
+    Gray,  // Reached but outgoing edges not yet traced (on marking worklist).
+    Black, // Reached and fully traced.
+};
+
 class GC_API Cell {
     AK_MAKE_NONCOPYABLE(Cell);
     AK_MAKE_NONMOVABLE(Cell);
@@ -48,8 +54,11 @@ class GC_API Cell {
 
     virtual ~Cell() = default;
 
-    bool is_marked() const { return m_mark; }
-    void set_marked(bool b) { m_mark = b; }
+    bool is_marked() const { return m_color != Color::White; }
+    void set_marked(bool b) { m_color = b ? Color::Black : Color::White; }
+
+    Color gc_color() const { return m_color; }
+    void set_gc_color(Color color) { m_color = color; }
 
     enum class State : bool {
         Live,
@@ -139,6 +148,13 @@ class GC_API Cell {
             visit_impl(ReadonlySpan<NanBoxedValue>(vector.span().data(), vector.size()));
         }
 
+        template<typename T>
+        void visit(ValueVector<T> const& vector)
+        requires(IsBaseOf<NanBoxedValue, T>)
+        {
+            visit_impl(ReadonlySpan<NanBoxedValue>(vector.span().data(), vector.size()));
+        }
+
         template<typename T>
         void visit(HashTable<T> const& table)
         {
@@ -215,7 +231,7 @@ class GC_API Cell {
     Cell() = default;
 
 private:
-    bool m_mark { false };
+    Color m_color { Color::White };
     State m_state { State::Live };
 };
 

Libraries/LibGC/DeferGC.h

@@ -10,6 +10,11 @@
 
 namespace GC {
 
+// Defers all garbage collection activity (both starting new cycles and
+// running incremental marking steps) for the lifetime of this object.
+// Write barriers remain active during deferral so the tri-color invariant
+// is preserved. When the last DeferGC is destroyed, a deferred collection
+// runs if one was requested.
 class GC_API DeferGC {
 public:
     explicit DeferGC(Heap& heap)

Libraries/LibGC/Forward.h

@@ -27,6 +27,12 @@ class Function;
 template<typename T>
 class HeapHashTable;
 
+template<class T>
+class RawPtr;
+
+template<class T>
+class RawRef;
+
 template<class T>
 class Root;
 
@@ -36,6 +42,9 @@ class ConservativeVector;
 template<class T>
 class HeapVector;
 
+template<class T>
+class ValueVector;
+
 template<class T, size_t inline_capacity = 0>
 class RootVector;