Add Bulk Operations for tools

So I am trying to submit a trivial change, but before I do that, I would like to know if this change will be acceptable. The idea is that today the MCP server does not support bulk operations for add tools or remove tools, and it is backed by a copy-on-write array list. So if I add a lot of tools, then every single time there is a copy that happens before a single tool gets committed, and that's not that great for performance when I would like to make changes to a lot of tools, for example.

Expected Behavior
Expected behavior is rather simple: I would like an API that lets me add several tools in bulk and that lets me remove several tools in bulk as well.

	/**
	 * Add a new tool specification at runtime.
	 * @param toolSpecification The tool specification to add
	 */
	public void addTool(McpStatelessServerFeatures.SyncToolSpecification toolSpecification) {
		this.asyncServer
			.addTool(McpStatelessServerFeatures.AsyncToolSpecification.fromSync(toolSpecification,
					this.immediateExecution))
			.block();
	}

	/**
	 * Add multiple tool specifications at runtime.
	 * @param toolSpecifications The tool specifications to add
	 */
	public void addTools(List<McpStatelessServerFeatures.SyncToolSpecification> toolSpecifications) {
		if (toolSpecifications == null) {
			this.asyncServer.addTools(null).block();
			return;
		}
		this.asyncServer
			.addTools(toolSpecifications.stream()
				.map(toolSpecification -> McpStatelessServerFeatures.AsyncToolSpecification.fromSync(toolSpecification,
						this.immediateExecution))
				.toList())
			.block();
	}

Current Behavior
The current behavior is that it just has a single method for add and remove

	/**
	 * Add a new tool specification at runtime.
	 * @param toolSpecification The tool specification to add
	 */
	public void addTool(McpStatelessServerFeatures.SyncToolSpecification toolSpecification) {
		this.asyncServer
			.addTool(McpStatelessServerFeatures.AsyncToolSpecification.fromSync(toolSpecification,
					this.immediateExecution))
			.block();
	}

Context

The reason we need this is because we are trying to create what sort of looks like an MCP gateway. For a lot of our internal tooling, these tool definitions come from a database. These tools can get enabled and disabled at runtime. There is also a use case where we interact with a lot of upstream MCP clients and publish out their tools as tools that we own ourselves. If one of those MCP clients goes bad or unhealthy for whatever reason or tries to remove the tools that we have access to, then that same thing should reflect for our clients as well, and it will be great to have that capability because if an MCP client or several MCP clients try to remove their tool all at once, we're looking at hundreds or tens of removals in a single shot. In some cases, maybe even hundreds or hundreds if we are dealing with two or three bigger MCP clients. That's the reason why we need this.

FYI, I have a PR that is already ready that I can immediately push if you guys think this is an acceptable change to introduce or allow addition and removal of tools in bulk.

Start by locating the server APIs around addTool, removeTool, asyncServer, and the SyncToolSpecification/AsyncToolSpecification conversions shown in the issue. Check how the current copy-on-write updates are committed, then implement bulk add and remove entry points with equivalent single-item behavior and verify that one bulk operation avoids repeated copies.