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/rust/string/string_split/src/factory.rs

@@ -0,0 +1,8 @@
+//! Factory for StringSplit plugin.
+
+use super::StringSplit;
+
+/// Creates a new StringSplit instance.
+pub fn create() -> StringSplit {
+    StringSplit::new()
+}

workflow/plugins/rust/string/string_split/src/lib.rs

@@ -1,28 +1,65 @@
 //! Workflow plugin: split a string.
 
 use serde_json::Value;
+use std::any::Any;
 use std::collections::HashMap;
 
-/// Split a string by separator.
-pub fn run(_runtime: &mut HashMap<String, Value>, inputs: &HashMap<String, Value>) -> Result<HashMap<String, Value>, String> {
-    let string: String = inputs
-        .get("string")
-        .and_then(|v| serde_json::from_value(v.clone()).ok())
-        .unwrap_or_default();
-    let separator: String = inputs
-        .get("separator")
-        .and_then(|v| serde_json::from_value(v.clone()).ok())
-        .unwrap_or_default();
+/// Trait for workflow node executors.
+pub trait NodeExecutor {
+    /// Execute the node with given inputs and optional runtime context.
+    fn execute(&self, inputs: HashMap<String, Value>, runtime: Option<&dyn Any>) -> HashMap<String, Value>;
+}
 
-    let result: Vec<String> = if separator.is_empty() {
-        string.chars().map(|c| c.to_string()).collect()
-    } else {
-        string.split(&separator).map(|s| s.to_string()).collect()
-    };
+/// StringSplit implements the NodeExecutor trait for splitting strings.
+pub struct StringSplit {
+    pub node_type: &'static str,
+    pub category: &'static str,
+    pub description: &'static str,
+}
 
-    let mut output = HashMap::new();
-    output.insert("result".to_string(), serde_json::json!(result));
-    Ok(output)
+impl StringSplit {
+    /// Creates a new StringSplit instance.
+    pub fn new() -> Self {
+        Self {
+            node_type: "string.split",
+            category: "string",
+            description: "Split a string by separator",
+        }
+    }
+}
+
+impl Default for StringSplit {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl NodeExecutor for StringSplit {
+    fn execute(&self, inputs: HashMap<String, Value>, _runtime: Option<&dyn Any>) -> HashMap<String, Value> {
+        let string: String = inputs
+            .get("string")
+            .and_then(|v| serde_json::from_value(v.clone()).ok())
+            .unwrap_or_default();
+        let separator: String = inputs
+            .get("separator")
+            .and_then(|v| serde_json::from_value(v.clone()).ok())
+            .unwrap_or_default();
+
+        let parts: Vec<String> = if separator.is_empty() {
+            string.chars().map(|c| c.to_string()).collect()
+        } else {
+            string.split(&separator).map(|s| s.to_string()).collect()
+        };
+
+        let mut result = HashMap::new();
+        result.insert("result".to_string(), serde_json::json!(parts));
+        result
+    }
+}
+
+/// Creates a new StringSplit instance.
+pub fn create() -> StringSplit {
+    StringSplit::new()
 }
 
 #[cfg(test)]
@@ -31,12 +68,19 @@ mod tests {
 
     #[test]
     fn test_split() {
-        let mut runtime = HashMap::new();
+        let executor = StringSplit::new();
         let mut inputs = HashMap::new();
         inputs.insert("string".to_string(), serde_json::json!("a,b,c"));
         inputs.insert("separator".to_string(), serde_json::json!(","));
 
-        let result = run(&mut runtime, &inputs).unwrap();
+        let result = executor.execute(inputs, None);
         assert_eq!(result.get("result"), Some(&serde_json::json!(["a", "b", "c"])));
     }
+
+    #[test]
+    fn test_factory() {
+        let executor = create();
+        assert_eq!(executor.node_type, "string.split");
+        assert_eq!(executor.category, "string");
+    }
 }