refactor: prefix every table with its module

Two tables were named after the concept they came from rather than the module
they belong to, so the schema read as if the template tables were part of the
paper module. Renamed (data preserved, `RENAME TABLE` moves rows in place):

    paper_template  -> template                 the 模板 module
    section_field   -> template_field_library   the 字段库 the 模板 module owns

The paper tables and `template_field` already followed the rule. The rename
carries through everything that named a module:

  models   Template, TemplateField, TemplateFieldLibrary
  schemas  Template*, TemplateFieldLibrary*
  crud     app/crud/template.py, app/crud/template_field_library.py
  API      /template-field-library (was /section-fields); handlers are now
           named after library entries, which removes the ambiguity with
           TemplateField — a placement, a different thing entirely
  client   src/api/templateFieldLibrary.ts

`paper_template_filed_sort` is deliberately untouched: it is a column of the
paper module, spelled as the feature was specified.

TiDB v8.5 with tidb_enable_foreign_key on — as this cluster runs — enforces
foreign keys rather than ignoring them, so the docs' "TiDB does not enforce
foreign keys" was wrong. Corrected, with what actually follows from it: the
rename was rehearsed (RENAME TABLE carries a referencing constraint along), the
API keeps checking first so a violation names the row instead of surfacing a
driver error, and the ORM cascades stay so behaviour does not depend on a
cluster setting.

Revision f27a1c6d9e04 verified both ways; 40 smoke checks, type-check and build
all pass.

backend/app/api/routes/templates.py

@@ -15,21 +15,21 @@ from fastapi import APIRouter, Depends, HTTPException, Query, Response, status
 from sqlalchemy.orm import Session
 
 from app.crud import paper as paper_crud
-from app.crud import paper_template as crud
+from app.crud import template as crud
 from app.db.session import get_db
-from app.models import PaperTemplate
+from app.models import Template
 from app.schemas.common import BatchDeleteRequest, BatchDeleteResult, PageResult
-from app.schemas.paper_template import (
-    PaperTemplateCreate,
-    PaperTemplateListItem,
-    PaperTemplateRead,
-    PaperTemplateUpdate,
+from app.schemas.template import (
+    TemplateCreate,
+    TemplateListItem,
+    TemplateRead,
+    TemplateUpdate,
 )
 
 router = APIRouter(prefix="/templates", tags=["templates"])
 
 
-def _get_or_404(db: Session, template_id: int) -> PaperTemplate:
+def _get_or_404(db: Session, template_id: int) -> Template:
     template = crud.get(db, template_id)
     if template is None:
         raise HTTPException(
@@ -60,7 +60,7 @@ def _assert_not_used_by_papers(db: Session, template_ids: list[int]) -> None:
 
     blockers = []
     for template_id, count in sorted(counts.items()):
-        template = db.get(PaperTemplate, template_id)
+        template = db.get(Template, template_id)
         name = template.name if template is not None else template_id
         blockers.append(f"“{name}”（{count} 篇论文）")
 
@@ -91,7 +91,7 @@ def _assert_fields_exist(db: Session, field_ids: list[int]) -> None:
 
 @router.get(
     "",
-    response_model=PageResult[PaperTemplateListItem],
+    response_model=PageResult[TemplateListItem],
     summary="List paper templates",
 )
 def list_templates(
@@ -99,7 +99,7 @@ def list_templates(
     keyword: str | None = Query(default=None, description="按模板名称或摘要模糊搜索"),
     page: int = Query(default=1, ge=1),
     page_size: int = Query(default=20, ge=1, le=200),
-) -> PageResult[PaperTemplateListItem]:
+) -> PageResult[TemplateListItem]:
     """Browse templates, most recently edited first."""
     items, total = crud.list_templates(
         db, keyword=keyword, page=page, page_size=page_size
@@ -109,14 +109,14 @@ def list_templates(
 
 @router.post(
     "",
-    response_model=PaperTemplateRead,
+    response_model=TemplateRead,
     status_code=status.HTTP_201_CREATED,
     summary="Create a paper template",
 )
 def create_template(
-    payload: PaperTemplateCreate,
+    payload: TemplateCreate,
     db: Session = Depends(get_db),
-) -> PaperTemplateRead:
+) -> TemplateRead:
     """Create a template from a name, an abstract, and a field selection."""
     _assert_name_free(db, payload.name)
     _assert_fields_exist(db, [item.field_id for item in payload.fields])
@@ -127,7 +127,7 @@ def create_template(
         abstract=payload.abstract,
         fields=payload.fields,
     )
-    return PaperTemplateRead.from_model(template)
+    return TemplateRead.from_model(template)
 
 
 @router.post(
@@ -146,24 +146,24 @@ def batch_delete_templates(
 
 @router.get(
     "/{template_id}",
-    response_model=PaperTemplateRead,
+    response_model=TemplateRead,
     summary="Fetch one paper template with its outline",
 )
-def get_template(template_id: int, db: Session = Depends(get_db)) -> PaperTemplateRead:
+def get_template(template_id: int, db: Session = Depends(get_db)) -> TemplateRead:
     """Return a template; ``fields`` arrives already ordered by ``sort``."""
-    return PaperTemplateRead.from_model(_get_or_404(db, template_id))
+    return TemplateRead.from_model(_get_or_404(db, template_id))
 
 
 @router.patch(
     "/{template_id}",
-    response_model=PaperTemplateRead,
+    response_model=TemplateRead,
     summary="Update a paper template",
 )
 def update_template(
     template_id: int,
-    payload: PaperTemplateUpdate,
+    payload: TemplateUpdate,
     db: Session = Depends(get_db),
-) -> PaperTemplateRead:
+) -> TemplateRead:
     """Update the name, the abstract, the field selection, or any combination.
 
     ``fields`` is a full replacement when present. Omitting it leaves the
@@ -186,7 +186,7 @@ def update_template(
         abstract_provided="abstract" in payload.model_fields_set,
         fields=payload.fields,
     )
-    return PaperTemplateRead.from_model(updated)
+    return TemplateRead.from_model(updated)
 
 
 @router.delete(