feat(classes): session roster + manual waitlist promotion

Adds the roster and manual promotion controls deferred from the booking
lifecycle milestones. Businesses can now inspect who holds a seat and who
is queueing on a class session, and promote waitlisted customers by hand
— including a deliberate over-capacity override when the session is full.

Backend:
- GET /v1/catalog/class-sessions/{id}/roster — session metadata plus
  confirmed and waitlist entry lists with queue positions
- POST /v1/catalog/bookings/{id}/promote — 409 on a full session unless
  allowOverCapacity is set; 400 for non-waitlisted, 404 for missing or
  foreign bookings; reuses the shared confirm path so waitlist ledger
  rows resolve and reminder jobs re-arm
- ListBookingsBySession repository method (pgx + memory); ClassSession
  carries waitlistCount; UpcomingBooking carries classSessionId and
  waitlistPosition
- OpenAPI paths + schemas, regenerated client, catalog service tests

Frontend:
- classes tab session rows expand into a two-column roster panel with
  per-entry promote buttons and an explicit confirm-anyway step on 409
- booking detail modal shows waitlist position and offers promote for
  waitlisted bookings; list badges show #N queue positions
- CS/EN i18n keys and seeded demo roster data; demo mutations surface
  the demo notice

Generated with [Devin](https://devin.ai)

Co-Authored-By: Devin <158243242+devin-ai-integration[bot]@users.noreply.github.com>

apps/backend/internal/db/bookings.go

@@ -50,6 +50,50 @@ func (r *PGRepository) ListBookingsByTenantBetween(ctx context.Context, tenantID
 	return records, rows.Err()
 }
 
+// ListBookingsBySession returns every booking on a class session in
+// creation order — the ordering that defines the waitlist queue.
+func (r *PGRepository) ListBookingsBySession(ctx context.Context, sessionID string) ([]BookingRecord, error) {
+	rows, err := r.pool.Query(ctx, `
+		SELECT id, tenant_id, service_id, class_session_id, staff_id, location_id,
+		       customer_name, customer_email, customer_phone, starts_at, ends_at, status, reference,
+		       COALESCE(manage_token, ''), COALESCE(notes, ''), created_at
+		FROM bookings
+		WHERE class_session_id = $1
+		ORDER BY created_at ASC
+	`, sessionID)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+
+	var records []BookingRecord
+	for rows.Next() {
+		var record BookingRecord
+		if err := rows.Scan(
+			&record.ID,
+			&record.TenantID,
+			&record.ServiceID,
+			&record.ClassSessionID,
+			&record.StaffID,
+			&record.LocationID,
+			&record.CustomerName,
+			&record.CustomerEmail,
+			&record.CustomerPhone,
+			&record.StartsAt,
+			&record.EndsAt,
+			&record.Status,
+			&record.Reference,
+			&record.ManageToken,
+			&record.Notes,
+			&record.CreatedAt,
+		); err != nil {
+			return nil, err
+		}
+		records = append(records, record)
+	}
+	return records, rows.Err()
+}
+
 func (r *PGRepository) CreateBooking(ctx context.Context, params CreateBookingParams) (CreatedBooking, error) {
 	var created CreatedBooking
 	err := r.pool.QueryRow(ctx, `

apps/backend/internal/db/repository.go

@@ -35,6 +35,7 @@ type Repository interface {
 	UpdateClassTemplate(ctx context.Context, templateID string, params CreateClassTemplateParams) (ClassTemplateRecord, error)
 	DeleteClassTemplate(ctx context.Context, templateID string) error
 	ListBookingsByTenantBetween(ctx context.Context, tenantID string, from time.Time, to time.Time) ([]BookingRecord, error)
+	ListBookingsBySession(ctx context.Context, sessionID string) ([]BookingRecord, error)
 	CreateBooking(ctx context.Context, params CreateBookingParams) (CreatedBooking, error)
 	AppendWaitlistEntry(ctx context.Context, params WaitlistEntryParams) error
 	ResolveWaitlistEntry(ctx context.Context, tenantID, sessionID, customerEmail string) error
@@ -1356,6 +1357,17 @@ func (r *MemoryRepository) ListBookingsByTenantBetween(_ context.Context, tenant
 	return out, nil
 }
 
+func (r *MemoryRepository) ListBookingsBySession(_ context.Context, sessionID string) ([]BookingRecord, error) {
+	var out []BookingRecord
+	for _, booking := range r.bookings {
+		if booking.ClassSessionID != nil && *booking.ClassSessionID == sessionID {
+			out = append(out, booking)
+		}
+	}
+	sort.SliceStable(out, func(i, j int) bool { return out[i].CreatedAt.Before(out[j].CreatedAt) })
+	return out, nil
+}
+
 func (r *MemoryRepository) CreateBooking(_ context.Context, params CreateBookingParams) (CreatedBooking, error) {
 	created := CreatedBooking{
 		ID:          uuid.NewString(),