docs: Add documentation for basic routing, requests and responses (#223)

## Description
This PR adds comprehensive documentation and examples for Relic's core
concepts, including:

- **Basic Routing Documentation**: Added complete guide
(`03-basic-routing.md`) covering route definition, HTTP methods,
handlers, and pipeline composition with working examples
- **Requests Documentation**: Added comprehensive guide
(`04-requests.md`) covering request properties, query parameters,
type-safe headers, body parsing, and validation best practices
- **Responses Documentation**: Added detailed guide (`05-responses.md`)
covering response creation, status codes, headers, body types, and error
handling patterns
- **Enhanced Code Documentation**: Added extensive inline documentation
to core classes including `Body`, `Request`, `Response`, `Headers`,
`Router`, `Handler`, `Pipeline`, and `Middleware`

### Code Examples
- **Basic Routing Example**: Created focused `basic_routing.dart`
demonstrating fundamental HTTP routing patterns
- **Comprehensive Example**: Completely refactored
`requets_response_example.dart` with all documentation examples in a
runnable format
- **Cross-Referenced Examples**: All documentation examples are
validated and present in the example files
- **Inline Documentation**: Updated core library classes with practical
examples and usage patterns

## Related Issues
- Closes: ?

## Pre-Launch Checklist
Please ensure that your PR meets the following requirements before
submitting:

- [x] This update focuses on a single feature or bug fix. (For multiple
fixes, please submit separate PRs.)
- [x] I have read and followed the [Dart Style
Guide](https://dart.dev/guides/language/effective-dart/style) and
formatted the code using [dart
format](https://dart.dev/tools/dart-format).
- [ ] I have referenced at least one issue this PR fixes or is related
to.
- [x] I have updated/added relevant documentation (doc comments with
`///`), ensuring consistency with existing project documentation.
- [x] I have added new tests to verify the changes.
- [x] All existing and new tests pass successfully.
- [x] I have documented any breaking changes below.

## Breaking Changes
- [x] No breaking changes.

---------

Co-authored-by: Kasper Overgård Nielsen <[email protected]>

Author: Zfinix

doc/outline.md

@@ -0,0 +1,126 @@
+---
+sidebar_position: 3
+---
+
+# Basic Routing
+
+_Routing_ refers to determining how an application responds to a client request to a particular endpoint, which is a URI (or path) and a specific HTTP request method (GET, POST, and so on).
+
+Each route can have one or more handler functions, which are executed when the route is matched.
+
+Route definition takes the following structure:
+
+```dart
+router.METHOD(PATH, HANDLER)
+```
+
+Where:
+
+- `router` is an instance of `Router<Handler>`.
+- `METHOD` is an HTTP request method, in lowercase.
+- `PATH` is a path on the server.
+- `HANDLER` is the function executed when the route is matched.
+
+## The `add` method and syntactic sugar
+
+At the core of routing is the `add` method:
+
+```dart
+router.add(Method.get, '/', handler);
+```
+
+The convenience methods like `.get()`, `.post()`, `.anyOf()`, and `.any()` are all syntactic sugar that call this underlying `add` method:
+
+- `.get(path, handler)` → `.add(Method.get, path, handler)`
+- `.post(path, handler)` → `.add(Method.post, path, handler)`
+- `.anyOf({Method.get, Method.post}, path, handler)` → calls `.add()` for each method in the set
+- `.any(path, handler)` → calls `.anyOf()` with all HTTP methods
+
+## Breaking Down the Routes
+
+The following examples break down each route from the complete example above.
+
+### Convenience methods (syntactic sugar)
+
+These methods are syntactic sugar for the core `.add()` method:
+
+**Respond with `Hello World!` on the homepage:**
+
+```dart
+app.get('/', (ctx) {
+  return ctx.respond(
+    Response.ok(
+      body: Body.fromString('Hello World!'),
+    ),
+  );
+});
+```
+
+**Respond to a POST request on the root route:**
+
+```dart
+app.post('/', (ctx) {
+  return ctx.respond(
+    Response.ok(
+      body: Body.fromString('Got a POST request'),
+    ),
+  );
+});
+```
+
+**Respond to a PUT request to the `/user` route:**
+
+```dart
+app.put('/user', (ctx) {
+  return ctx.respond(
+    Response.ok(
+      body: Body.fromString('Got a PUT request at /user'),
+    ),
+  );
+});
+```
+
+**Respond to a DELETE request to the `/user` route:**
+
+```dart
+app.delete('/user', (ctx) {
+  return ctx.respond(
+    Response.ok(
+      body: Body.fromString('Got a DELETE request at /user'),
+    ),
+  );
+});
+```
+
+### Using the `add` method
+
+This is what the convenience methods call internally:
+
+**Respond to a PATCH request using the core `.add()` method:**
+
+```dart
+app.add(Method.patch, '/api', (ctx) {
+  return ctx.respond(
+    Response.ok(
+      body: Body.fromString('Got a PATCH request at /api'),
+    ),
+  );
+});
+```
+
+### Using `anyOf` for Multiple Methods
+
+Handle multiple HTTP methods with the same handler:
+
+**Handle both GET and POST requests to `/admin`:**
+
+```dart
+app.anyOf({Method.get, Method.post}, '/admin', (ctx) {
+  final method = ctx.request.method.name.toUpperCase();
+  return ctx.respond(Response.ok(body: Body.fromString('Admin page - $method request')));
+});
+```
+
+## Examples
+
+- **[`basic_routing.dart`](https://github.com/serverpod/relic/blob/main/example/basic_routing.dart)** - The complete working example from this guide