RBAC-04: modul-scoped-berechtigungen

internal/policy/module_scope.go: policy_module_scopes verknuepft optional
eine (role, permission)-Regel mit einem LIC-02-Feature-Flag. Enforcer.
AuthorizeForTenant ist DIESELBE zentrale Entscheidungsfunktion wie Authorize
(Akzeptanzkriterium 3, kein zweiter Enforcement-Mechanismus) — prueft
zusaetzlich zur Grundregel, ob das verknuepfte Modul fuer den Tenant aktiv
ist. Existiert kein ModuleScope-Eintrag, bleibt eine Regel wie bisher ohne
Lizenzbindung gueltig (Kombinationsfall). GuardModuleScoped erweitert
policy.Guard um dieselbe Pruefung.

internal/flag (LIC-02) wurde 1:1 aus dem lic-02-Branch uebernommen (git show
aus derselben Repo-Historie, keine Aenderung) — RBAC-04 haengt sowohl an
RBAC-01/02 als auch an LIC-02, aber diese leben auf getrennten, noch nicht
gemergten Feature-Branches ohne gemeinsame Historie.

Fail-Safe-Verhalten aus LIC-02 greift automatisch: ein nicht konfiguriertes
oder nicht erreichbares Feature-Flag gilt als deaktiviert, nie als aktiviert
(sicherer Default fuer Modul-Aktivierungspruefungen).

Pruefungen (ausgefuehrt auf root@192.168.1.131, go build/vet/test PASS):
1. Zugriff auf deaktiviertes Modul trotz passender Rolle abgewiesen —
   TestAuthorizeForTenant_DeniesWhenModuleNotActivated: GuardModuleScoped
   ruft die Query-Funktion nachweislich nicht auf. PASS.
2. Reaktivierung macht Berechtigung im laufenden Betrieb wirksam, kein
   Neustart — TestAuthorizeForTenant_BecomesActiveWithoutRestart: derselbe
   Enforcer/Service-Prozess, Flag per Store.Set aktiviert, TTL abgewartet,
   danach erlaubt. PASS.
3. Zusammenspiel Modul-Scope + Rollenscope in Kombinationsfaellen —
   TestAuthorizeForTenant_CombinationsOfRoleAndModuleScope: keine Regel ->
   verboten; Regel ohne Modul-Scope -> immer erlaubt; Regel mit Modul-Scope
   und Flag aus -> verboten; Flag an -> erlaubt. PASS.

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

internal/flag/flag.go

@@ -0,0 +1,87 @@
+// Package flag implementiert Core LIC-02: einen Feature-Flag-Dienst mit
+// Strategien (global an/aus, Prozentsatz, Tenant-Zielgruppe) als Kernfunktion
+// des Core-Dienstes selbst — keine zusaetzliche Infrastruktur (Unleash-Server
+// + eigene DB), siehe "bewusst vermeiden" im LIC-02-Ticket.
+package flag
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"hash/fnv"
+
+	"github.com/jackc/pgx/v5"
+	"github.com/jackc/pgx/v5/pgxpool"
+)
+
+var ErrNotFound = errors.New("flag: nicht gefunden")
+
+// Flag ist die zentrale Definition — Auswertung (Evaluate) ist bewusst davon
+// getrennt (Unleash-Prinzip: Flag-Verwaltung vs. Flag-Auswertung).
+type Flag struct {
+	Key               string
+	Enabled           bool
+	RolloutPercentage int
+	TargetTenantSlugs []string
+}
+
+// Store ist die Verwaltungsseite (Admin): Flags definieren/lesen.
+type Store struct {
+	pool *pgxpool.Pool
+}
+
+func NewStore(pool *pgxpool.Pool) *Store {
+	return &Store{pool: pool}
+}
+
+func (s *Store) Set(ctx context.Context, f Flag) error {
+	if f.TargetTenantSlugs == nil {
+		f.TargetTenantSlugs = []string{} // pgx uebertraegt ein nil-Slice sonst als SQL NULL statt leerem Array.
+	}
+	_, err := s.pool.Exec(ctx, `
+		INSERT INTO feature_flags (key, enabled, rollout_percentage, target_tenant_slugs, updated_at)
+		VALUES ($1, $2, $3, $4, now())
+		ON CONFLICT (key) DO UPDATE SET
+			enabled = $2, rollout_percentage = $3, target_tenant_slugs = $4, updated_at = now()
+	`, f.Key, f.Enabled, f.RolloutPercentage, f.TargetTenantSlugs)
+	if err != nil {
+		return fmt.Errorf("flag speichern: %w", err)
+	}
+	return nil
+}
+
+func (s *Store) Get(ctx context.Context, key string) (Flag, error) {
+	var f Flag
+	row := s.pool.QueryRow(ctx, `
+		SELECT key, enabled, rollout_percentage, target_tenant_slugs
+		FROM feature_flags WHERE key = $1
+	`, key)
+	if err := row.Scan(&f.Key, &f.Enabled, &f.RolloutPercentage, &f.TargetTenantSlugs); err != nil {
+		if errors.Is(err, pgx.ErrNoRows) {
+			return Flag{}, ErrNotFound
+		}
+		return Flag{}, fmt.Errorf("flag lesen: %w", err)
+	}
+	return f, nil
+}
+
+// evaluate wendet die Strategien in fester Reihenfolge an: globaler
+// An/Aus-Schalter zuerst, dann Tenant-Zielgruppe, dann Prozentsatz-Rollout.
+// Ein unbekannter/nicht getroffener Fall ergibt false — Fail-Safe-Default,
+// kein Feature wird versehentlich aktiv.
+func evaluate(f Flag, tenantSlug string) bool {
+	if f.Enabled {
+		return true
+	}
+	for _, target := range f.TargetTenantSlugs {
+		if target == tenantSlug {
+			return true
+		}
+	}
+	if f.RolloutPercentage > 0 {
+		h := fnv.New32a()
+		_, _ = h.Write([]byte(f.Key + "|" + tenantSlug))
+		return int(h.Sum32()%100) < f.RolloutPercentage
+	}
+	return false
+}