Remove Programs tab and all supporting code

The Programs feature is superseded by Shows, which provides a more
flexible model with schedule slots. This commit removes all Programs
code across frontend and backend:

Frontend:
- Delete admin-program-form component (ts/html/scss)
- Delete program.service.ts and program.ts interface
- Remove Programs tab, form modal, and all CRUD logic from admin
  component (ts + html)

Backend:
- Delete programs API router
- Remove Program ORM model and ProgramCreate/Update/Response schemas
- Remove programs router registration from main.py
- Remove Program from seed data, seed helpers, and truncate/reset

backend/app/api/admin.py

@@ -2,7 +2,7 @@ from fastapi import APIRouter
 
 from app.config import settings
 from app.database import get_session
-from app.models import DonationTier, Event, Program, StationConfig, Show, ShowSchedule
+from app.models import DonationTier, Event, StationConfig, Show, ShowSchedule
 
 router = APIRouter()
 
@@ -19,7 +19,6 @@ async def reset_database():
     async with async_session() as session:
         await session.execute(ShowSchedule.__table__.delete())
         await session.execute(Show.__table__.delete())
-        await session.execute(Program.__table__.delete())
         await session.execute(Event.__table__.delete())
         await session.execute(DonationTier.__table__.delete())
         await session.execute(StationConfig.__table__.delete())

backend/app/api/programs.py

@@ -1,84 +0,0 @@
-from typing import Optional
-
-from fastapi import APIRouter, Depends, Query
-from sqlalchemy import select, func
-from sqlalchemy.ext.asyncio import AsyncSession
-
-from app.auth import get_current_admin_user
-from app.database import get_session
-from app.models import Program
-from app.schemas import ProgramCreate, ProgramUpdate, ProgramResponse
-from app.user_models import User
-
-router = APIRouter()
-
-
-def _day_filter(day: int):
-    """Return the SQLAlchemy filter for a given day_of_week."""
-    return Program.day_of_week == day
-
-
-@router.get("/", response_model=list[ProgramResponse])
-async def list_programs(
-    day: Optional[int] = Query(None, description="Filter by day_of_week (1=Mon … 7=Sun)"),
-    session: AsyncSession = Depends(get_session),
-):
-    query = select(Program).order_by(Program.day_of_week, Program.time)
-    if day is not None:
-        query = query.filter(_day_filter(day))
-    result = await session.execute(query)
-    return list(result.scalars().all())
-
-
-@router.get("/{program_id}", response_model=ProgramResponse)
-async def get_program(program_id: int, session: AsyncSession = Depends(get_session)):
-    result = await session.execute(select(Program).where(Program.id == program_id))
-    program = result.scalar_one_or_none()
-    if not program:
-        return {"error": "Program not found"}
-    return program
-
-
-@router.post("/", response_model=ProgramResponse, status_code=201)
-async def create_program(
-    payload: ProgramCreate,
-    session: AsyncSession = Depends(get_session),
-    _: User = Depends(get_current_admin_user),
-):
-    program = Program(**payload.model_dump())
-    session.add(program)
-    await session.commit()
-    await session.refresh(program)
-    return program
-
-
-@router.put("/{program_id}", response_model=ProgramResponse)
-async def update_program(
-    program_id: int,
-    payload: ProgramUpdate,
-    session: AsyncSession = Depends(get_session),
-    _: User = Depends(get_current_admin_user),
-):
-    result = await session.execute(select(Program).where(Program.id == program_id))
-    program = result.scalar_one_or_none()
-    if not program:
-        return {"error": "Program not found"}
-    for key, value in payload.model_dump(exclude_unset=True).items():
-        setattr(program, key, value)
-    await session.commit()
-    await session.refresh(program)
-    return program
-
-
-@router.delete("/{program_id}", status_code=204)
-async def delete_program(
-    program_id: int,
-    session: AsyncSession = Depends(get_session),
-    _: User = Depends(get_current_admin_user),
-):
-    result = await session.execute(select(Program).where(Program.id == program_id))
-    program = result.scalar_one_or_none()
-    if not program:
-        return {"error": "Program not found"}
-    await session.delete(program)
-    await session.commit()