refactor: replace decorator-based handlers with RequestHandler/NotificationHandler pattern

- Extract RequestHandler class into request_handler.py with typed overloads
- Extract NotificationHandler class into notification_handler.py with typed overloads
- Refactor Server to dispatch by method string instead of request type
- Remove decorator methods, tool cache, and request_ctx contextvar
- Delete new_server.py sketch (superseded by extracted handler files)

Known breakages: MCPServer, ExperimentalHandlers, tests, examples

Author: maxisbey

src/mcp/server/lowlevel/__init__.py

@@ -1,3 +1,5 @@
+from .notification_handler import NotificationHandler
+from .request_handler import RequestHandler
 from .server import NotificationOptions, Server
 
-__all__ = ["Server", "NotificationOptions"]
+__all__ = ["NotificationHandler", "NotificationOptions", "RequestHandler", "Server"]

src/mcp/server/lowlevel/new_server.py

@@ -0,0 +1,69 @@
+"""Notification handler for the low-level MCP server."""
+
+from collections.abc import Awaitable, Callable
+from typing import Any, Generic, Literal, overload
+
+from typing_extensions import TypeVar
+
+from mcp.server.session import ServerSession
+from mcp.shared.context import RequestContext
+from mcp.types import (
+    CancelledNotificationParams,
+    NotificationParams,
+    ProgressNotificationParams,
+)
+
+LifespanResultT = TypeVar("LifespanResultT", default=Any)
+RequestT = TypeVar("RequestT", default=Any)
+
+Ctx = RequestContext[ServerSession, LifespanResultT, RequestT]
+
+
+class NotificationHandler(Generic[LifespanResultT, RequestT]):
+    """Handler for MCP notification methods.
+
+    Each handler is associated with a method string (e.g. "notifications/progress") and
+    an async endpoint function that receives a RequestContext and the notification params.
+    """
+
+    @overload
+    def __init__(
+        self,
+        method: Literal["notifications/initialized"],
+        handler: Callable[[Ctx, NotificationParams | None], Awaitable[None]],
+    ) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        method: Literal["notifications/cancelled"],
+        handler: Callable[[Ctx, CancelledNotificationParams], Awaitable[None]],
+    ) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        method: Literal["notifications/progress"],
+        handler: Callable[[Ctx, ProgressNotificationParams], Awaitable[None]],
+    ) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        method: Literal["notifications/roots/list_changed"],
+        handler: Callable[[Ctx, NotificationParams | None], Awaitable[None]],
+    ) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        method: str,
+        handler: Callable[..., Awaitable[None]],
+    ) -> None: ...
+
+    def __init__(self, method: str, handler: Callable[..., Awaitable[None]]) -> None:
+        self.method = method
+        self.endpoint = handler
+
+    async def handle(self, ctx: Ctx, params: Any) -> None:
+        await self.endpoint(ctx, params)