feat: add to_state() method to RunResult for resuming runs

This commit adds a method to convert a RunResult back into a RunState,
enabling the resume workflow for interrupted runs.

**Changes:**

1. **to_state() Method** (result.py:125-165)
   - Added method to RunResult class
   - Creates a new RunState from the result's data
   - Populates generated_items, model_responses, and guardrail results
   - Includes comprehensive docstring with usage example

**How to Use:**

```python
# Run agent until it needs approval
result = await Runner.run(agent, "Use the delete_file tool")

if result.interruptions:
    # Convert result to state
    state = result.to_state()

    # Approve the tool call
    state.approve(result.interruptions[0])

    # Resume the run
    result = await Runner.run(agent, state)
```

**Complete HITL Flow:**

1. Run agent with tool that needs_approval=True
2. Run pauses, returns RunResult with interruptions
3. User calls result.to_state() to get RunState
4. User calls state.approve() or state.reject()
5. User passes state back to Runner.run() to resume
6. Run continues from where it left off

**Remaining Work:**
- Add comprehensive tests
- Create example demonstrating HITL
- Add documentation

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

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

Author: mjschock

src/agents/result.py

@@ -122,6 +122,48 @@ def last_agent(self) -> Agent[Any]:
         """The last agent that was run."""
         return self._last_agent
 
+    def to_state(self) -> Any:
+        """Create a RunState from this result to resume execution.
+
+        This is useful when the run was interrupted (e.g., for tool approval). You can
+        approve or reject the tool calls on the returned state, then pass it back to
+        `Runner.run()` to continue execution.
+
+        Returns:
+            A RunState that can be used to resume the run.
+
+        Example:
+            ```python
+            # Run agent until it needs approval
+            result = await Runner.run(agent, "Use the delete_file tool")
+
+            if result.interruptions:
+                # Approve the tool call
+                state = result.to_state()
+                state.approve(result.interruptions[0])
+
+                # Resume the run
+                result = await Runner.run(agent, state)
+            ```
+        """
+        from .run_state import RunState
+
+        # Create a RunState from the current result
+        state = RunState(
+            context=self.context_wrapper,
+            original_input=self.input,
+            starting_agent=self.last_agent,
+            max_turns=10,  # This will be overridden by the runner
+        )
+
+        # Populate the state with data from the result
+        state._generated_items = self.new_items
+        state._model_responses = self.raw_responses
+        state._input_guardrail_results = self.input_guardrail_results
+        state._output_guardrail_results = self.output_guardrail_results
+
+        return state
+
     def __str__(self) -> str:
         return pretty_print_result(self)