feat: add rules engine (internal/rules) with first two disclosure rules

internal/rules implements Stufe 2 from the core principle: the LLM
extracts facts, this deterministic engine judges them against versioned
YAML rules. Facts/Condition/Rule/Finding types, a loader that refuses to
load on a missing id/version or a duplicate rule id rather than silently
skipping a bad file, and Evaluate() matching facts against rules.

Two real rules grounded in verified research (see rules/OPEN.md for the
open questions that surfaced along the way):
- WK-001: no disclosure at all despite consideration (§ 5a Abs. 4 UWG,
  § 22 Abs. 1 MStV)
- WK-004: disclosure present but hidden behind a "mehr anzeigen" cut
  (§ 5a Abs. 4 UWG, Leitfaden der Medienanstalten, LG Köln 12.05.2026)

The two are deliberately disjoint (WK-004 requires disclosure_present=
true) so a post with no disclosure at all doesn't double-fire both
rules. Golden suite in testdata/golden/ covers both rules plus two clean
cases; it's this suite, not the UI, that's the actual asset per
CLAUDE.md.

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

internal/rules/rule_test.go

@@ -0,0 +1,105 @@
+package rules_test
+
+import (
+	"testing"
+	"testing/fstest"
+
+	"github.com/netcell-it/deklarix/internal/rules"
+)
+
+func TestLoadRejectsMissingID(t *testing.T) {
+	fsys := fstest.MapFS{
+		"bad.yaml": &fstest.MapFile{Data: []byte("version: 1\ntitel: x\nschwere: hoch\n")},
+	}
+	if _, err := rules.Load(fsys); err == nil {
+		t.Fatal("expected error for rule without id, got nil")
+	}
+}
+
+func TestLoadRejectsMissingVersion(t *testing.T) {
+	fsys := fstest.MapFS{
+		"bad.yaml": &fstest.MapFile{Data: []byte("id: WK-999\ntitel: x\nschwere: hoch\n")},
+	}
+	if _, err := rules.Load(fsys); err == nil {
+		t.Fatal("expected error for rule without version, got nil")
+	}
+}
+
+func TestLoadRejectsDuplicateID(t *testing.T) {
+	fsys := fstest.MapFS{
+		"a.yaml": &fstest.MapFile{Data: []byte("id: WK-999\nversion: 1\ntitel: x\nschwere: hoch\n")},
+		"b.yaml": &fstest.MapFile{Data: []byte("id: WK-999\nversion: 2\ntitel: y\nschwere: hoch\n")},
+	}
+	if _, err := rules.Load(fsys); err == nil {
+		t.Fatal("expected error for duplicate rule id, got nil")
+	}
+}
+
+func TestLoadIgnoresNonYAMLFiles(t *testing.T) {
+	fsys := fstest.MapFS{
+		"a.yaml":    &fstest.MapFile{Data: []byte("id: WK-999\nversion: 1\ntitel: x\nschwere: hoch\n")},
+		"README.md": &fstest.MapFile{Data: []byte("not a rule")},
+	}
+	got, err := rules.Load(fsys)
+	if err != nil {
+		t.Fatalf("Load: %v", err)
+	}
+	if len(got) != 1 {
+		t.Fatalf("expected 1 rule, got %d", len(got))
+	}
+}
+
+func TestConditionMatches(t *testing.T) {
+	yes := true
+	no := false
+
+	cases := []struct {
+		name string
+		cond rules.Condition
+		fact rules.Facts
+		want bool
+	}{
+		{
+			name: "consideration list matches",
+			cond: rules.Condition{Consideration: []rules.Consideration{rules.ConsiderationPaid}},
+			fact: rules.Facts{Consideration: rules.ConsiderationPaid},
+			want: true,
+		},
+		{
+			name: "consideration list does not match",
+			cond: rules.Condition{Consideration: []rules.Consideration{rules.ConsiderationPaid}},
+			fact: rules.Facts{Consideration: rules.ConsiderationNone},
+			want: false,
+		},
+		{
+			name: "disclosure present must match",
+			cond: rules.Condition{DisclosurePresent: &no},
+			fact: rules.Facts{DisclosurePresent: true},
+			want: false,
+		},
+		{
+			name: "unset fields impose no constraint",
+			cond: rules.Condition{},
+			fact: rules.Facts{Consideration: rules.ConsiderationUnclear},
+			want: true,
+		},
+		{
+			name: "all constraints must hold (AND)",
+			cond: rules.Condition{
+				Consideration:       []rules.Consideration{rules.ConsiderationPaid},
+				DisclosurePresent:   &yes,
+				DisclosureBeforeCut: &no,
+			},
+			fact: rules.Facts{Consideration: rules.ConsiderationPaid, DisclosurePresent: true, DisclosureBeforeCut: false},
+			want: true,
+		},
+	}
+
+	for _, tc := range cases {
+		t.Run(tc.name, func(t *testing.T) {
+			if got := tc.cond.Matches(tc.fact); got != tc.want {
+				t.Fatalf("Matches() = %v, want %v", got, tc.want)
+			}
+		})
+	}
+}