openai_agents: tool wrapper is re-applied on every turn

### How do you use Sentry?

Sentry SaaS (sentry.io)

### Version

2.68.1

### Steps to Reproduce

We ran into the tool-rebuild problem that #6961 fixed. Our agent crash-looped on `UserError: ToolSearchTool() requires at least one searchable Responses surface`, because `defer_loading` came back `False` on every tool. Moving to 2.67.0 fixed it for us, and the switch to `RunHooks` in #6994 looks like the right call.

While reading that fix I noticed one thing still worth reporting in `patches/tools.py`. It now sets `on_invoke_tool` in place:

```python
tool.on_invoke_tool = create_wrapped_invoke(tool, original_on_invoke)
```

`get_all_tools` returns the agent's own tool objects and runs once per turn, so the wrapper goes on again on each turn and the previous one stays underneath it.

That file is only wired up for `openai-agents < 0.3.2`, so this repro calls `_get_all_tools` directly with a stub standing in for the original:

```python
import asyncio, sentry_sdk
sentry_sdk.init(dsn="https://a@b.ingest.sentry.io/1", traces_sample_rate=1.0)
from sentry_sdk.integrations.openai_agents.patches.tools import _get_all_tools
from agents import Agent, FunctionTool

async def invoke(ctx, args): return "ok"

tool = FunctionTool(
name="t", description="d",
params_json_schema={"type": "object", "properties": {}, "additionalProperties": False},
on_invoke_tool=invoke,
)
agent = Agent(name="a", tools=[tool])

async def original(a, c): return list(a.tools) # stands in for get_all_tools

async def main():
for turn in range(1, 6):
await _get_all_tools(original, agent, None)
f, depth = agent.tools[0].on_invoke_tool, 0
while hasattr(f, "__wrapped__"):
f, depth = f.__wrapped__, depth + 1
print(f"after turn {turn}: wrapper depth = {depth}")

asyncio.run(main())
```

### Expected Result

A tool gets wrapped once, however many turns a run takes, and one tool call produces one `gen_ai.execute_tool` span.

### Actual Result

```
after turn 1: wrapper depth = 1
after turn 2: wrapper depth = 2
after turn 3: wrapper depth = 3
after turn 4: wrapper depth = 4
after turn 5: wrapper depth = 5
```

A tool call on turn N opens N nested `gen_ai.execute_tool` spans, and the wrapping stays on the caller's `Agent` after the run.

`_patch_run_hooks` in `patches/runner.py` already guards against this with `_sentry_is_patched`. The same flag on the tool would cover it.

Tested on Python 3.13 with `openai-agents` 0.17.5.