feat(skills): add Inertia skill + resourceful controller in FastAPI skill

fastapi_startkit/src/fastapi_startkit/skills/registry.py

@@ -35,6 +35,9 @@ class SkillRegistry:
         "database": [
             ".ai/fastapi-startkit/database/SKILL.md",
         ],
+        "inertia": [
+            ".ai/fastapi-startkit/inertia/SKILL.md",
+        ],
     }
 
     def __init__(self, app: "Application") -> None:

fastapi_startkit/src/fastapi_startkit/skills/stubs/.ai/fastapi-startkit/fastapi/SKILL.md

@@ -13,36 +13,76 @@ from fastapi_startkit.fastapi import Router
 router = Router()
 ```
 
-and use the crud resources, for example
+and register routes explicitly, for example
 ```python
+router.get("/users", users_controller.index)
 router.post("/users", users_controller.store)
+router.get("/users/{user_id}", users_controller.show)
 router.put("/users/{user_id}", users_controller.update)
-router.patch("/users/{user_id}", users_controller.patch)
-router.delete("/users", users_controller.destroy)
+router.patch("/users/{user_id}", users_controller.update)
+router.delete("/users/{user_id}", users_controller.destroy)
 ```
 
-the controller will look like
-```python
-# app/http/controllers/users_controller.py
-async def index(request: Request):
-    pass
+### Resourceful controllers
 
-async def show(user_id: int):
-    pass
+Prefer `router.resource()` to register the seven standard CRUD routes in one
+call. It maps to a **resourceful controller** with these methods:
 
-async def store(data: UserSchema):
-    pass
+| Method    | Verb & URI                  | Purpose                          |
+|-----------|-----------------------------|----------------------------------|
+| `index`   | GET `/users`                | List the collection              |
+| `create`  | GET `/users/create`         | Show the "new" form              |
+| `store`   | POST `/users`               | Persist a new record             |
+| `show`    | GET `/users/{user}`         | Show a single record             |
+| `edit`    | GET `/users/{user}/edit`    | Show the "edit" form             |
+| `update`  | PUT/PATCH `/users/{user}`   | Persist changes to a record      |
+| `destroy` | DELETE `/users/{user}`      | Delete a record                  |
 
-async def update(user_id: int, data: UserSchema):
-    pass
+```python
+# routes/web.py
+router.resource("users", users_controller)
 
-async def destroy(user_id: int):
-    pass
+# subset / exclusions
+router.resource("users", users_controller, only=['index', 'show'])
+router.resource("users", users_controller, excepts=['create', 'edit'])
 ```
 
-or use the resource function as:
+A full resourceful controller mirrors those seven methods exactly:
 ```python
-router.resource("users", users_controller, excepts=['create', 'edit'])
+# app/http/controllers/users_controller.py
+from fastapi_startkit.jsonapi import JsonResource
+
+from app.models import User
+from app.http.requests.user_store_request import UserStoreRequest
+
+async def index():
+    users = await User.all()
+    return JsonResource.collection(users)
+
+async def create():
+    # render/return the "create" form payload
+    ...
+
+async def store(request: UserStoreRequest):
+    user = await User.create(request.model_dump())
+    return JsonResource(user)
+
+async def show(user: int):
+    return JsonResource(await User.find_or_fail(user))
+
+async def edit(user: int):
+    # render/return the "edit" form payload for the record
+    return JsonResource(await User.find_or_fail(user))
+
+async def update(user: int, request: UserStoreRequest):
+    record = await User.find_or_fail(user)
+    await record.update(request.model_dump())
+    return JsonResource(record)
+
+async def destroy(user: int):
+    record = await User.find_or_fail(user)
+    await record.delete()
+    return JsonResource(record)
 ```
 
 ## ORM