Overhaul tool handling (#89)

* Overhaul tool handling

- Renames [McpTool{Type}] to [McpServerTool{Type}], in order to distinguish representations of tools on the server from tools on the client.
- Enables [McpServerTool] methods to have arguments injected from DI, as well as a specific set of types from the implementation directly, like IMcpServer.
- Renames WithTools to WithToolsFromAssembly.
- All of the WithToolsXx methods now publish each individual McpServerTool into DI; other code can do so as well. The options setup code gathers all of the tools from DI and combines them into a collection which is then stored in McpServerOptions and used to construct the server.
- The server tools specified via DI as well as manually-provided handlers, using CallToolHandler as a fallback in case the requested tool doesn't exist in the tools collection, and ListToolsHandler augments the information for whatever tools exist.
- The tools are stored in McpServerOptions in a new McpServerToolCollection type, which is a thread-safe container that exposes add/removal notification. Adding/removing tools triggers a change notification that in turn sends a notification to the client about a tools update.
- The ServerOptions are exposed from the server instance.
- Removed cursor-based APIs from McpClientExtensions.
- Changed McpClientExtensions APIs to return `Task<IList<...>` rather than `IAsyncEnumerable<...>`.

I'm sure this will need to evolve further before we're "done", but it's a significant improvement from where we are now. One area I'm not super happy with is the notifying collection; that might work ok for a stdio server, where you can grab the created collection from the server's options and mutate it, but I don't know how well that's going to work for sse servers.

* Make McpServerTool{Collection} extensible

* Fix README.md example

* Add notifications test

* Address feedback

src/ModelContextProtocol/Server/DelegatingMcpServerTool.cs

@@ -0,0 +1,34 @@
+using ModelContextProtocol.Protocol.Types;
+using ModelContextProtocol.Utils;
+
+namespace ModelContextProtocol.Server;
+
+/// <summary>Provides an <see cref="McpServerTool"/> that delegates all operations to an inner <see cref="McpServerTool"/>.</summary>
+/// <remarks>
+/// This is recommended as a base type when building tools that can be chained around an underlying <see cref="McpServerTool"/>.
+/// The default implementation simply passes each call to the inner tool instance.
+/// </remarks>
+public abstract class DelegatingMcpServerTool : McpServerTool
+{
+    private readonly McpServerTool _innerTool;
+
+    /// <summary>Initializes a new instance of the <see cref="DelegatingMcpServerTool"/> class around the specified <paramref name="innerTool"/>.</summary>
+    /// <param name="innerTool">The inner tool wrapped by this delegating tool.</param>
+    protected DelegatingMcpServerTool(McpServerTool innerTool)
+    {
+        Throw.IfNull(innerTool);
+        _innerTool = innerTool;
+    }
+
+    /// <inheritdoc />
+    public override Tool ProtocolTool => _innerTool.ProtocolTool;
+
+    /// <inheritdoc />
+    public override Task<CallToolResponse> InvokeAsync(
+        RequestContext<CallToolRequestParams> request, 
+        CancellationToken cancellationToken = default) =>
+        _innerTool.InvokeAsync(request, cancellationToken);
+
+    /// <inheritdoc />
+    public override string ToString() => _innerTool.ToString();
+}