LibJS: Elide function wrapper for class field literal initializers

If a class field initializer is just a simple literal, we can skip
creating (and calling) a wrapper function for it entirely.

1.44x speedup on JetStream3/raytrace-private-class-fields.js
1.53x speedup on JetStream3/raytrace-public-class-fields.js

Libraries/LibJS/Runtime/ClassFieldDefinition.h

@@ -17,8 +17,8 @@ using ClassElementName = Variant<PropertyKey, PrivateName>;
 
 // 6.2.10 The ClassFieldDefinition Record Specification Type, https://tc39.es/ecma262/#sec-classfielddefinition-record-specification-type
 struct ClassFieldDefinition {
-    ClassElementName name;                         // [[Name]]
-    GC::Ptr<ECMAScriptFunctionObject> initializer; // [[Initializer]]
+    ClassElementName name;                                                // [[Name]]
+    Variant<GC::Ref<ECMAScriptFunctionObject>, Value, Empty> initializer; // [[Initializer]]
 };
 
 }

Libraries/LibJS/Runtime/ECMAScriptFunctionObject.cpp

@@ -553,7 +553,14 @@ void ECMAScriptFunctionObject::visit_edges(Visitor& visitor)
     visitor.visit(m_bytecode_executable);
 
     for (auto& field : m_fields) {
-        visitor.visit(field.initializer);
+        field.initializer.visit(
+            [&visitor](GC::Ref<ECMAScriptFunctionObject>& initializer) {
+                visitor.visit(initializer);
+            },
+            [&visitor](Value initializer) {
+                visitor.visit(initializer);
+            },
+            [](Empty) {});
         if (auto* property_key_ptr = field.name.get_pointer<PropertyKey>(); property_key_ptr && property_key_ptr->is_symbol())
             visitor.visit(property_key_ptr->as_symbol());
     }

Libraries/LibJS/Runtime/Object.cpp

@@ -669,9 +669,14 @@ ThrowCompletionOr<void> Object::define_field(ClassFieldDefinition const& field)
     auto init_value = js_undefined();
 
     // 3. If initializer is not empty, then
-    if (initializer) {
-        // a. Let initValue be ? Call(initializer, receiver).
-        init_value = TRY(call(vm, initializer, this));
+    if (!initializer.has<Empty>()) {
+        // OPTIMIZATION: If the initializer is a value (from a literal), we can skip the call.
+        if (auto const* initializer_value = initializer.get_pointer<Value>()) {
+            init_value = *initializer_value;
+        } else {
+            // a. Let initValue be ? Call(initializer, receiver).
+            init_value = TRY(call(vm, *initializer.get<GC::Ref<ECMAScriptFunctionObject>>(), this));
+        }
     }
     // 4. Else, let initValue be undefined.