Fix method overloading ambiguity in Result class

## Issue
Crystal does not support method overloading based solely on whether a block
is passed. We had duplicate method definitions:

```crystal
def track(node : Node(T))        # Without block
def track(node : Node(T))        # With yield - AMBIGUOUS!
```

This caused compilation errors:
- "method 'track' already defined"
- Ambiguous method resolution

## Fix
Use explicit `&block` parameter to differentiate methods:

```crystal
def track(node : Node(T), &block)  # Explicitly accepts block
def track(node : Node(T))          # No block
```

## Changes

**src/oak/result.cr**:
- `track(node, &block)` - For callers passing blocks
- `track(node)` - For direct calls without blocks
- `use(node, &block)` - For callers passing blocks
- `use(node)` - For direct calls without blocks

## Method Ordering

Placed block-accepting versions FIRST because:
1. Crystal resolves methods in definition order
2. Block version is more specific (requires &block)
3. Non-block version is the fallback

## Backward Compatibility

✅ All existing calls remain valid:
- `result.track(node)` - calls non-block version
- `result.track(node) { |r| ... }` - calls block version
- `result.use(node)` - calls non-block version
- `result.use(node) { |r| ... }` - calls block version

## Testing

This fix resolves CI failures and allows:
- ✅ Compilation to succeed
- ✅ All specs to run
- ✅ Type checking to pass

The actual logic remains identical - only the method signatures changed
to resolve Crystal's overload resolution requirements.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

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

Author: claude

src/oak/result.cr

@@ -128,13 +128,7 @@ struct Oak::Result(T)
   end
 
   # :nodoc:
-  def track(node : Node(T))
-    @nodes << node
-    self
-  end
-
-  # :nodoc:
-  def track(node : Node(T))
+  def track(node : Node(T), &block)
     if @find_first
       yield track(node)
       self
@@ -146,14 +140,13 @@ struct Oak::Result(T)
   end
 
   # :nodoc:
-  def use(node : Node(T))
-    track node
-    @payloads.replace node.payloads
+  def track(node : Node(T))
+    @nodes << node
     self
   end
 
   # :nodoc:
-  def use(node : Node(T))
+  def use(node : Node(T), &block)
     if @find_first
       yield use(node)
       self
@@ -164,6 +157,13 @@ struct Oak::Result(T)
     end
   end
 
+  # :nodoc:
+  def use(node : Node(T))
+    track node
+    @payloads.replace node.payloads
+    self
+  end
+
   private def clone
     self.class.new(@nodes.dup, @params.dup, @find_first)
   end