perf(function): cache ValueFactory dispatch table (#442)

<!-- devin-review-badge-begin -->

---

<a href="https://app.devin.ai/review/iamgio/quarkdown/pull/442" target="_blank">
  <picture>
    <source media="(prefers-color-scheme: dark)" srcset="https://static.devin.ai/assets/gh-open-in-devin-review-dark.svg?v=1">
    <img src="https://static.devin.ai/assets/gh-open-in-devin-review-light.svg?v=1" alt="Open with Devin">
  </picture>
</a>
<!-- devin-review-badge-end -->

Author: iamgio

quarkdown-core/src/main/kotlin/com/quarkdown/core/function/reflect/DynamicValueConverter.kt

@@ -15,6 +15,26 @@ import kotlin.reflect.full.findAnnotations
 import kotlin.reflect.full.functions
 import kotlin.reflect.full.isSubclassOf
 
+/**
+ * A cached entry in the [FromDynamicType] dispatch table,
+ * pairing a factory method with its annotation metadata.
+ */
+private data class FactoryEntry(
+    val function: KFunction<*>,
+    val annotation: FromDynamicType,
+)
+
+/**
+ * Cached dispatch table of [ValueFactory] methods annotated with [FromDynamicType].
+ */
+private val factoryEntries: List<FactoryEntry> by lazy {
+    ValueFactory::class.declaredFunctions.flatMap { function ->
+        function.findAnnotations<FromDynamicType>().map { annotation ->
+            FactoryEntry(function, annotation)
+        }
+    }
+}
+
 /**
  * A converter of a value that potentially holds any type (its value is stored as a plain string)
  * to a specific, statically defined [Value] type that can be used as an input for a function call argument.
@@ -54,25 +74,25 @@ class DynamicValueConverter(
                 ?: throw NoSuchElementException(element = raw, values)
         }
 
-        // Gets ValueFactory methods annotated with @FromDynamicType(X::class),
-        // and the one with a matching type is invoked.
-        for (function in ValueFactory::class.declaredFunctions) {
-            val annotations = function.findAnnotations<FromDynamicType>()
-            val from = annotations.find { type.isSubclassOf(it.unwrappedType) } ?: continue
+        // Looks up the pre-built dispatch table for a matching factory method.
+        for ((function, annotation) in factoryEntries) {
+            if (!type.isSubclassOf(annotation.unwrappedType)) continue
 
             // The factory method is suitable. Invoking it.
 
             return try {
                 when {
                     // Fetch the context from the function call if it's required.
-                    from.requiresContext -> {
+                    annotation.requiresContext -> {
                         if (context == null) {
                             throw IllegalStateException("Function call does not have an attached context")
                         }
                         function.call(ValueFactory, raw, context)
                     }
 
-                    else -> function.call(ValueFactory, raw)
+                    else -> {
+                        function.call(ValueFactory, raw)
+                    }
                 } as InputValue<*>?
             } catch (e: InvocationTargetException) {
                 throw e.cause ?: e