refactor(skills): restructure skills following skill-creator best practices

Major improvements aligned with skill-creator guidelines:

1. **SKILL.md Size Reduction** (71% decrease)
   - Before: 4,691 lines total across all skills
   - After: 1,378 lines total
   - act-setup: 519 → 119 lines (77% ↓)
   - state-management: 693 → 236 lines (66% ↓)
   - node-implementation: 805 → 265 lines (67% ↓)
   - graph-composition: 825 → 143 lines (83% ↓)
   - modules-integration: 774 → 133 lines (83% ↓)
   - testing-debugging: 728 → 135 lines (81% ↓)

2. **Progressive Disclosure Structure**
   - SKILL.md: Core workflows and quick reference (<5k words)
   - references/: Detailed guides (loaded as needed)
   - examples/: Working code examples
   - scripts/: Validation and utility scripts
   - templates/: Reusable templates

3. **Imperative/Infinitive Writing Style**
   - Changed from second-person to command-form instructions
   - "Use when..." instead of "You should use when..."
   - More consistent AI consumption format

4. **Examples Added**
   state-management/:
   - simple_state.py - Basic data processing state
   - message_state.py - Chat/agent state with messages
   - complex_state.py - Multi-layer state with tracking

   node-implementation/:
   - simple_nodes.py - BaseNode and function patterns

5. **Directory Structure**
   Each skill now has proper structure:
   - SKILL.md (lean, <250 lines typically)
   - references/ (for detailed documentation)
   - examples/ (for working code)
   - scripts/ (for validation tools)
   - templates/ (for reusable templates)

6. **Dual Pattern Support**
   - node-implementation: Both BaseNode and function approaches
   - Aligned with actual template code patterns

This restructuring enables:
- Faster skill loading (smaller SKILL.md)
- Better progressive disclosure
- Clearer usage patterns
- More maintainable documentation
- Consistency with skill-creator best practices

Author: claude

act_operator/act_operator/scaffold/{{ cookiecutter.act_slug }}/.claude/skills/act-setup/SKILL.md

@@ -0,0 +1,57 @@
+"""Simple node examples - BaseNode and function approaches.
+
+Demonstrates basic node patterns for transforming state.
+"""
+
+from casts.base_node import BaseNode
+
+
+# BaseNode Approach (Recommended)
+class UppercaseNode(BaseNode):
+    """Convert query to uppercase using BaseNode."""
+
+    def execute(self, state):
+        """Transform query to uppercase.
+
+        Args:
+            state: Graph state with query field
+
+        Returns:
+            dict: State update with result
+        """
+        result = state.query.upper()
+        return {"result": result}
+
+
+# Function Approach (Simpler for basic transformations)
+def uppercase_node(state):
+    """Convert query to uppercase using function.
+
+    Args:
+        state: Graph state with query field
+
+    Returns:
+        dict: State update with result
+    """
+    result = state.query.upper()
+    return {"result": result}
+
+
+# Usage in graph
+if __name__ == "__main__":
+    from dataclasses import dataclass
+
+    @dataclass(kw_only=True)
+    class State:
+        query: str
+        result: str = ""
+
+    # Test BaseNode
+    node_instance = UppercaseNode()
+    test_state = State(query="hello world")
+    result = node_instance(test_state)
+    print(f"BaseNode result: {result}")
+
+    # Test function node
+    result = uppercase_node(test_state)
+    print(f"Function result: {result}")