refactor: refactor tool macros and router implementation (#261)

* refactor: refactor tool macros and router implementation

- Updated the `#[tool(tool_box)]` macro to `#[tool_router]` across various modules for consistency.
- Enhanced the `Calculator`, `Counter`, and `GenericService` structs to utilize `ToolRouter` for handling tool calls.
- Introduced `Parameters` struct for better parameter handling in tool functions.
- Added new methods for listing tools and calling tools in server handlers.
- Improved test cases to reflect changes in tool routing and parameter handling.
- Updated documentation and examples to align with the new router structure.

* fix: fix fmt and build error

* fix: fix test failure

* docs: documents for macros, fix ci

* fix: fix ci

* fix: fix wrongly replaced documents

* fix: remove useless file

* fix: change the parameter format for tool_router

* fix: update extract_doc_line to handle existing documentation and clean up unused code in server handler

* doc: update document for macro and examples

* doc: update readme and add contribute guide

* fix: fix type

crates/rmcp-macros/src/tool_handler.rs

@@ -0,0 +1,51 @@
+use darling::{FromMeta, ast::NestedMeta};
+use proc_macro2::TokenStream;
+use quote::{ToTokens, quote};
+use syn::{Expr, ImplItem, ItemImpl};
+
+#[derive(FromMeta)]
+#[darling(default)]
+pub struct ToolHandlerAttribute {
+    pub router: Expr,
+}
+
+impl Default for ToolHandlerAttribute {
+    fn default() -> Self {
+        Self {
+            router: syn::parse2(quote! {
+                self.tool_router
+            })
+            .unwrap(),
+        }
+    }
+}
+
+pub fn tool_handler(attr: TokenStream, input: TokenStream) -> syn::Result<TokenStream> {
+    let attr_args = NestedMeta::parse_meta_list(attr)?;
+    let ToolHandlerAttribute { router } = ToolHandlerAttribute::from_list(&attr_args)?;
+    let mut item_impl = syn::parse2::<ItemImpl>(input.clone())?;
+    let tool_call_fn = quote! {
+        async fn call_tool(
+            &self,
+            request: rmcp::model::CallToolRequestParam,
+            context: rmcp::service::RequestContext<rmcp::RoleServer>,
+        ) -> Result<rmcp::model::CallToolResult, rmcp::Error> {
+            let tcc = rmcp::handler::server::tool::ToolCallContext::new(self, request, context);
+            #router.call(tcc).await
+        }
+    };
+    let tool_list_fn = quote! {
+        async fn list_tools(
+            &self,
+            _request: Option<rmcp::model::PaginatedRequestParam>,
+            _context: rmcp::service::RequestContext<rmcp::RoleServer>,
+        ) -> Result<rmcp::model::ListToolsResult, rmcp::Error> {
+            Ok(rmcp::model::ListToolsResult::with_all_items(#router.list_all()))
+        }
+    };
+    let tool_call_fn = syn::parse2::<ImplItem>(tool_call_fn)?;
+    let tool_list_fn = syn::parse2::<ImplItem>(tool_list_fn)?;
+    item_impl.items.push(tool_call_fn);
+    item_impl.items.push(tool_list_fn);
+    Ok(item_impl.into_token_stream())
+}