perf: eliminate JVM regression in lazy stdlib init

- Share LazyConstMember objects in StdLibModule companion object so they
  are reused across Interpreter instances — after first evaluation, cached
  values are returned directly without closure invocation or Map lookup.
- Null out init closure after first invoke to release references for GC.
- Replace synchronized lazy val functionMap with unsynchronized var +
  null-check in AbstractFunctionModule (single-threaded evaluator).

Author: He-Pin

sjsonnet/src/sjsonnet/Val.scala

@@ -639,12 +639,12 @@ object Val {
      * A member whose value is created lazily on first access. Used by stdlib to defer builtin
      * function instantiation until actually needed, reducing startup overhead.
      */
-    final class LazyConstMember(add2: Boolean, visibility2: Visibility, init: () => Val)
+    final class LazyConstMember(add2: Boolean, visibility2: Visibility, private var init: () => Val)
         extends Member(add2, visibility2, cached = true, deprecatedSkipAsserts = true) {
       private var _val: Val = _
       def invoke(self: Obj, sup: Obj, fs: FileScope, ev: EvalScope): Val = {
         var v = _val
-        if (v eq null) { v = init(); _val = v }
+        if (v eq null) { v = init(); _val = v; init = null }
         v
       }
     }

sjsonnet/src/sjsonnet/functions/AbstractFunctionModule.scala

@@ -18,14 +18,18 @@ abstract class AbstractFunctionModule extends FunctionModule {
   def functions: Seq[(String, Val.Func)]
 
   /**
-   * Lazy function lookup map, built on first access to any function in this module.
+   * Unsynchronized lazy function lookup map — single-threaded, no synchronization needed.
    */
-  private lazy val functionMap: Map[String, Val.Func] = functions.toMap
+  private var _functionMap: Map[String, Val.Func] = _
 
   /**
    * Get a function by name, triggering module initialization if needed.
    */
-  def getFunction(name: String): Val.Func = functionMap(name)
+  def getFunction(name: String): Val.Func = {
+    var m = _functionMap
+    if (m eq null) { m = functions.toMap; _functionMap = m }
+    m(name)
+  }
 
   /**
    * the holder of the module object

sjsonnet/src/sjsonnet/stdlib/StdLibModule.scala

@@ -26,17 +26,14 @@ final class StdLibModule(
 
   val module: Val.Obj = {
     // Estimate total size: module functions + additional std functions + native/trace/extVar + pi/thisFile
-    val totalSize = nameToModule.size + additionalStdFunctions.size + 3 + additionalStdMembers.size
+    val totalSize =
+      sharedLazyMembers.size + additionalStdFunctions.size + 3 + additionalStdMembers.size
     val entries = Util.preSizedJavaLinkedHashMap[String, Val.Obj.Member](totalSize)
 
-    // Lazy members — Val.Builtin created on first access, per-module granularity
-    val iter = nameToModule.entrySet().iterator()
-    while (iter.hasNext) {
-      val e = iter.next()
-      val n = e.getKey
-      val m = e.getValue
-      entries.put(n, new Val.Obj.LazyConstMember(false, Visibility.Hidden, () => m.getFunction(n)))
-    }
+    // Shared lazy members — created once in companion object, reused across all instances.
+    // After first StdLibModule evaluation, LazyConstMember._val is populated and subsequent
+    // instances get the cached values directly (single null-check fast path).
+    entries.putAll(sharedLazyMembers)
 
     // Additional std functions (eager — typically empty or small)
     for ((k, v) <- additionalStdFunctions)
@@ -85,6 +82,21 @@ object StdLibModule {
     m
   }
 
+  // Shared LazyConstMember objects — created once at class loading, reused across all
+  // StdLibModule instances. After first evaluation, each member caches its resolved Val.Func,
+  // so subsequent instances pay only a null-check per member access (no closure or Map lookup).
+  private val sharedLazyMembers: java.util.LinkedHashMap[String, Val.Obj.Member] = {
+    val m = new java.util.LinkedHashMap[String, Val.Obj.Member](256)
+    val iter = nameToModule.entrySet().iterator()
+    while (iter.hasNext) {
+      val e = iter.next()
+      val n = e.getKey
+      val mod = e.getValue
+      m.put(n, new Val.Obj.LazyConstMember(false, Visibility.Hidden, () => mod.getFunction(n)))
+    }
+    m
+  }
+
   // Core std library functions that belong directly in StdLibModule
   private val traceFunction = new Val.Builtin2("trace", "str", "rest") {
     def evalRhs(str: Eval, rest: Eval, ev: EvalScope, pos: Position): Val = {