Retrait des compétences ; disponibilités en fenêtres horaires libres

Compétences supprimées de bout en bout :
- tables `skill`, `volunteer_skill`, `shift_required_skill` ;
- `Volunteer.skill_codes`, `Shift.required_skill_codes`, colonne `skills`
  de l'import, règle de validation `MISSING_REQUIRED_SKILL`, jeu de démo.

Disponibilités repensées : `Availability` passe de (`day_part_id`,
`status` tri-état) à une **fenêtre horaire libre** (`date`, `start_time`,
`end_time` ; `end <= start` ⇒ passe minuit), plusieurs par jour.
- Nouveaux endpoints `GET`/`PUT /editions/{id}/volunteers/{vid}/availability`
  (PUT = remplacement complet, COORDINATION) et
  `GET /editions/{id}/availability` (toute l'édition, pour la grille).
- `OUTSIDE_AVAILABILITY` (toujours WARNING) : compare le créneau à l'union
  des fenêtres du bénévole ce jour-là ; renvoie `date` + `uncovered_minutes`.
  `DayPart` ne sert plus qu'à la borne de « journée » du cumul 8 h.
- L'import ne gère plus les disponibilités (fenêtres saisies dans l'app) :
  `values.py` supprimé, mapping réduit à nom/email/téléphone/commentaire.

Migration 0007 (recrée `availability`). `AvailabilityStatus` supprimé.
158 tests, `alembic check` et `ruff` au vert. Front à suivre.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_017uUsRg7XzopkCPWimwg9ZM

backend/app/api/availability.py

@@ -0,0 +1,132 @@
+"""Disponibilités déclarées par les bénévoles.
+
+Une disponibilité = « le <date>, je peux de <start_time> à <end_time> ».
+Fenêtre horaire libre (pas liée aux créneaux types) ; plusieurs par jour
+possibles. `end_time <= start_time` ⇒ la fenêtre se termine le lendemain.
+
+Ces fenêtres sont prises en compte par le moteur de validation (règle
+`OUTSIDE_AVAILABILITY`) au moment d'affecter un bénévole à un créneau.
+"""
+
+import uuid
+
+from fastapi import APIRouter, Depends, HTTPException
+from sqlalchemy import delete
+from sqlmodel import Session, select
+
+from app.api._common import owned_or_404
+from app.api.deps import get_edition
+from app.api.schemas import AvailabilityRead, AvailabilitySet
+from app.auth.deps import (
+    current_account_in_edition,
+    require_coordinator,
+    require_staff,
+)
+from app.db import get_session
+from app.models import Account, Availability, Edition, Role, Volunteer
+
+router = APIRouter(prefix="/editions/{edition_id}", tags=["availability"])
+
+
+def _ensure_can_read(account: Account, volunteer_id: uuid.UUID) -> None:
+    if account.role in (Role.COORDINATOR, Role.LEAD):
+        return
+    if account.volunteer_id == volunteer_id:
+        return
+    raise HTTPException(status_code=403, detail={"code": "error.forbidden"})
+
+
+def _windows(session: Session, volunteer_id: uuid.UUID) -> list[Availability]:
+    return list(
+        session.exec(
+            select(Availability)
+            .where(Availability.volunteer_id == volunteer_id)
+            .order_by(Availability.date, Availability.start_time)
+        )
+    )
+
+
+@router.get(
+    "/volunteers/{volunteer_id}/availability",
+    response_model=list[AvailabilityRead],
+)
+def list_availability(
+    volunteer_id: uuid.UUID,
+    edition: Edition = Depends(get_edition),
+    account: Account = Depends(current_account_in_edition),
+    session: Session = Depends(get_session),
+) -> list[Availability]:
+    _ensure_can_read(account, volunteer_id)
+    owned_or_404(session.get(Volunteer, volunteer_id), edition.id)
+    return _windows(session, volunteer_id)
+
+
+@router.put(
+    "/volunteers/{volunteer_id}/availability",
+    response_model=list[AvailabilityRead],
+)
+def replace_availability(
+    volunteer_id: uuid.UUID,
+    payload: AvailabilitySet,
+    edition: Edition = Depends(get_edition),
+    _guard: Account = Depends(require_coordinator),
+    session: Session = Depends(get_session),
+) -> list[Availability]:
+    owned_or_404(session.get(Volunteer, volunteer_id), edition.id)
+
+    for w in payload.windows:
+        if not edition.start_date <= w.date <= edition.end_date:
+            raise HTTPException(
+                status_code=422,
+                detail={
+                    "code": "availability.date_outside_edition",
+                    "params": {"date": w.date.isoformat()},
+                },
+            )
+        if w.start_time == w.end_time:
+            raise HTTPException(
+                status_code=422,
+                detail={"code": "availability.empty_window"},
+            )
+
+    session.execute(
+        delete(Availability).where(Availability.volunteer_id == volunteer_id)
+    )
+    # Dé-doublonne (date, start, end) : la contrainte d'unicité l'imposerait.
+    seen: set[tuple] = set()
+    for w in payload.windows:
+        key = (w.date, w.start_time, w.end_time)
+        if key in seen:
+            continue
+        seen.add(key)
+        session.add(
+            Availability(
+                edition_id=edition.id,
+                volunteer_id=volunteer_id,
+                date=w.date,
+                start_time=w.start_time,
+                end_time=w.end_time,
+            )
+        )
+    session.commit()
+    return _windows(session, volunteer_id)
+
+
+@router.get("/availability", response_model=list[AvailabilityRead])
+def list_edition_availability(
+    edition: Edition = Depends(get_edition),
+    _guard: Account = Depends(require_staff),
+    session: Session = Depends(get_session),
+) -> list[Availability]:
+    """Toutes les disponibilités de l'édition (pour la grille des besoins)."""
+    return list(
+        session.exec(
+            select(Availability)
+            .where(Availability.edition_id == edition.id)
+            .order_by(
+                Availability.volunteer_id,
+                Availability.date,
+                Availability.start_time,
+            )
+        )
+    )