Add #[tool] macro for ergonomic tool creation

[grainier]

Introduces a procedural macro that simplifies tool definition and refactors tool storage for better ergonomics and performance.

Key Changes

1. #[tool] macro generates tool structs - Function name becomes the tool name
2. Storage refactoring - Changed from Arc<dyn BaseTool> to Box<dyn BaseTool> for unique ownership
3. Borrowed tool references - BaseToolset::get_tools() now returns Vec<&dyn BaseTool> with lifetimes
4. Generic tool registration - with_tool() accepts any BaseTool implementation

Usage

Before:

let weather_tool = Arc::new(FunctionTool::new(
    "get_weather",
    "Get current weather",
    |args: HashMap<String, Value>, _ctx: &ToolContext| {
        Box::pin(async move {
            let location: String = serde_json::from_value(
                args.get("location").cloned().unwrap_or_default()
            )?;
            ToolResult::success(json!({
                "temperature": 72.5,
                "condition": "sunny",
                "location": location
            }))
        })
    },
));

let worker = LlmWorker::builder(llm)
    .with_tool(weather_tool)
    .build();

After:

#[derive(Deserialize, JsonSchema)]
struct GetWeatherArgs {
    location: String,
}

#[tool(description = "Get current weather")]
async fn get_weather(args: GetWeatherArgs) -> ToolResult {
    ToolResult::success(json!({
        "temperature": 72.5,
        "condition": "sunny",
        "location": args.location
    }))
}

// Use it - function name becomes tool name, struct-based tool
let worker = LlmWorker::builder(llm)
    .with_tool(get_weather)  // Pass struct directly, no Arc wrapper needed
    .build();

Benefits

• Less boilerplate - No manual FunctionTool::new() or Arc wrapping
• Type safety - Structured args with serde validation and JSON schema generation
• Better ergonomics - Tool name derived from function name automatically
• Clearer ownership - Box for unique ownership, borrowed references for access
• Efficient sharing - No Arc cloning overhead in toolsets

Implementation Details

The macro generates a zero-sized struct that implements BaseTool:

#[derive(Clone, Copy, Debug)]
struct get_weather;

impl BaseTool for get_weather {
    fn name(&self) -> &str { "get_weather" }
    fn description(&self) -> &str { "Get current weather" }
    // ... schema and execute implementation
}

Toolsets store tools as Vec<Box<dyn BaseTool>> and return borrowed references via get_tools() -> Vec<&dyn BaseTool>, eliminating unnecessary Arc cloning while maintaining efficient access patterns.