refactor: restructure internal/ into adapters/, infra/, and app layers

- internal/gemini/ → internal/adapters/openai/ (renamed package to openai)
- internal/pexels/ → internal/adapters/pexels/
- internal/config/   → internal/infra/config/
- internal/database/ → internal/infra/database/
- internal/locale/   → internal/infra/locale/
- internal/middleware/ → internal/infra/middleware/
- internal/server/   → internal/infra/server/

All import paths and call sites updated accordingly.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

backend/internal/infra/locale/locale.go

@@ -0,0 +1,102 @@
+package locale
+
+import (
+	"context"
+	"fmt"
+	"net/http"
+	"strings"
+
+	"github.com/jackc/pgx/v5/pgxpool"
+)
+
+// Default is the fallback language when no supported language is detected.
+const Default = "en"
+
+// Supported is the set of language codes the application currently handles.
+// Keys are ISO 639-1 two-letter codes (lower-case).
+// Populated by LoadFromDB at server startup.
+var Supported = map[string]bool{
+	"en": true,
+	"ru": true,
+}
+
+// Language is a supported language record loaded from the DB.
+type Language struct {
+	Code        string
+	NativeName  string
+	EnglishName string
+}
+
+// Languages is the ordered list of active languages.
+// Populated by LoadFromDB at server startup.
+var Languages []Language
+
+// LoadFromDB queries the languages table and updates both Supported and Languages.
+// Must be called once at startup before the server begins accepting requests.
+func LoadFromDB(ctx context.Context, pool *pgxpool.Pool) error {
+	rows, err := pool.Query(ctx,
+		`SELECT code, native_name, english_name FROM languages WHERE is_active ORDER BY sort_order`)
+	if err != nil {
+		return fmt.Errorf("load languages from db: %w", err)
+	}
+	defer rows.Close()
+
+	newSupported := map[string]bool{}
+	var newLanguages []Language
+	for rows.Next() {
+		var l Language
+		if err := rows.Scan(&l.Code, &l.NativeName, &l.EnglishName); err != nil {
+			return err
+		}
+		newSupported[l.Code] = true
+		newLanguages = append(newLanguages, l)
+	}
+	if err := rows.Err(); err != nil {
+		return err
+	}
+	Supported = newSupported
+	Languages = newLanguages
+	return nil
+}
+
+type contextKey struct{}
+
+// Parse returns the best-matching supported language from an Accept-Language
+// header value.  It iterates through the comma-separated list in preference
+// order and returns the first entry whose primary subtag is in Supported.
+// Returns Default when the header is empty or no match is found.
+func Parse(acceptLang string) string {
+	if acceptLang == "" {
+		return Default
+	}
+	for part := range strings.SplitSeq(acceptLang, ",") {
+		// Strip quality value (e.g. ";q=0.9").
+		tag := strings.TrimSpace(strings.SplitN(part, ";", 2)[0])
+		// Use only the primary subtag (e.g. "ru" from "ru-RU").
+		lang := strings.ToLower(strings.SplitN(tag, "-", 2)[0])
+		if Supported[lang] {
+			return lang
+		}
+	}
+	return Default
+}
+
+// WithLang returns a copy of ctx carrying the given language code.
+func WithLang(ctx context.Context, lang string) context.Context {
+	return context.WithValue(ctx, contextKey{}, lang)
+}
+
+// FromContext returns the language stored in ctx.
+// Returns Default when no language has been set.
+func FromContext(ctx context.Context) string {
+	if lang, ok := ctx.Value(contextKey{}).(string); ok && lang != "" {
+		return lang
+	}
+	return Default
+}
+
+// FromRequest extracts the preferred language from the request's
+// Accept-Language header.
+func FromRequest(r *http.Request) string {
+	return Parse(r.Header.Get("Accept-Language"))
+}