refactor(workflow): convert all plugins to class/struct + factory pattern

- Python: class extending NodeExecutor + factory.py (80+ plugins)
- TypeScript: class implements NodeExecutor + factory.ts (7 groups, 116 classes)
- Go: struct with methods + factory.go (36 plugins)
- Rust: struct impl NodeExecutor trait + factory.rs (54 plugins)
- Mojo: struct + factory.mojo (11 plugins)

All package.json files now include:
- files array listing source files
- metadata.class/struct field
- metadata.entrypoint field

This enables a unified plugin loading system across all languages
with no import side effects (Spring-style DI pattern).

Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com>

workflow/plugins/mojo/string/string_concat/factory.mojo

@@ -0,0 +1,12 @@
+"""Factory for StringConcat plugin."""
+
+from .string_concat import StringConcat
+
+
+fn create() -> StringConcat:
+    """Create a new StringConcat plugin instance.
+
+    Returns:
+        A new StringConcat plugin instance.
+    """
+    return StringConcat()

workflow/plugins/mojo/string/string_concat/package.json

@@ -6,8 +6,11 @@
   "license": "MIT",
   "keywords": ["string", "workflow", "plugin"],
   "main": "string_concat.mojo",
+  "files": ["string_concat.mojo", "factory.mojo"],
   "metadata": {
     "plugin_type": "string.concat",
-    "category": "string"
+    "category": "string",
+    "struct": "StringConcat",
+    "entrypoint": "execute"
   }
 }

workflow/plugins/mojo/string/string_concat/string_concat.mojo

@@ -1,47 +1,64 @@
-# Workflow plugin: concatenate strings
-#
-# Concatenates multiple strings together with an optional separator.
-# Input: {"strings": ["Hello", "World"], "separator": " "}
-# Output: {"result": "Hello World"}
+"""Workflow plugin: concatenate strings.
+
+Concatenates multiple strings together with an optional separator.
+Input: {"strings": ["Hello", "World"], "separator": " "}
+Output: {"result": "Hello World"}
+"""
 
 from collections import Dict
 from python import PythonObject
 
 
-fn run(inputs: Dict[String, PythonObject]) -> Dict[String, PythonObject]:
-    """Concatenate multiple strings with an optional separator.
+struct StringConcat:
+    """Plugin that concatenates multiple strings with an optional separator."""
 
-    Args:
-        inputs: Dictionary containing:
-            - "strings": List of strings to concatenate
-            - "separator": Optional separator string (default: "")
+    var node_type: String
+    var category: String
+    var description: String
 
-    Returns:
-        Dictionary with "result" key containing the concatenated string.
-    """
-    var strings = inputs.get("strings", PythonObject([]))
-    var separator = String(inputs.get("separator", PythonObject("")))
-    var output = Dict[String, PythonObject]()
+    fn __init__(inout self):
+        """Initialize the StringConcat plugin."""
+        self.node_type = "string.concat"
+        self.category = "string"
+        self.description = "Concatenate multiple strings with optional separator"
 
-    var length = len(strings)
-    if length == 0:
-        output["result"] = PythonObject("")
+    fn execute(self, inputs: Dict[String, PythonObject], runtime: PythonObject = PythonObject(None)) -> Dict[String, PythonObject]:
+        """Concatenate multiple strings with an optional separator.
+
+        Args:
+            inputs: Dictionary containing:
+                - "strings": List of strings to concatenate
+                - "separator": Optional separator string (default: "")
+            runtime: Optional runtime context (unused).
+
+        Returns:
+            Dictionary with "result" key containing the concatenated string.
+        """
+        var strings = inputs.get("strings", PythonObject([]))
+        var separator = String(inputs.get("separator", PythonObject("")))
+        var output = Dict[String, PythonObject]()
+
+        var length = len(strings)
+        if length == 0:
+            output["result"] = PythonObject("")
+            return output
+
+        var result = String(strings[0])
+
+        for i in range(1, length):
+            result += separator + String(strings[i])
+
+        output["result"] = PythonObject(result)
         return output
 
-    var result = String(strings[0])
-
-    for i in range(1, length):
-        result += separator + String(strings[i])
-
-    output["result"] = PythonObject(result)
-    return output
-
 
 fn main():
     """Test the concat plugin."""
+    var plugin = StringConcat()
+
     var inputs = Dict[String, PythonObject]()
     inputs["strings"] = PythonObject(["Hello", "World"])
     inputs["separator"] = PythonObject(" ")
 
-    var result = run(inputs)
+    var result = plugin.execute(inputs)
     print("Concatenated:", result["result"])  # Expected: "Hello World"