addrkit: quality evaluation harness + parser hardening

- add internal/eval: deterministic citizen-style perturbation harness
  (typos, case, word order, abbreviations, filler words, dropped units)
- parser: strip all street-type tokens, filler words (город/дом/д/область),
  trailing apartment (кв N); handle letter-before-fraction and corpus letters
- matching: token-aware typo-tolerant street similarity; wider ambiguity
  margin to surface near-collisions instead of guessing
- seed: correct parse-rate accounting, structure-aware de-duplication
- CLI: 'addrkit eval' command; README with measured results

Measured on the real 73,936-row registry: 99.98% parsed, 0 wrong-house
safety violations across 34k+ perturbed cases.

internal/domain/address/parse.go

@@ -20,6 +20,10 @@ var (
 
 	// "2-я", "10-й", "3-е"
 	reOrdinalToken = regexp.MustCompile(`^(\d+)-[а-я]{1,3}$`)
+
+	// Trailing apartment part: " кв 5", " квартира 12", " кв. 7а". Removed
+	// before house parsing so it cannot leak into the street name.
+	reApartment = regexp.MustCompile(`(?:^|\s)(?:квартира|кв)\.?(?:\s+\d+[а-я]?)?\s*$`)
 )
 
 // Parse decomposes a free-form address into its structured components. It is
@@ -27,6 +31,8 @@ var (
 // part is best-effort and whose HasHouse is false.
 func Parse(raw string) ParsedAddress {
 	normalized := NormalizeText(raw)
+	// A trailing apartment ("кв 5") is not part of the address identity.
+	normalized = strings.TrimSpace(reApartment.ReplaceAllString(normalized, ""))
 	p := ParsedAddress{Raw: raw, Normalized: normalized}
 
 	rest := normalized
@@ -69,28 +75,42 @@ func firstNonEmpty(values ...string) string {
 
 // parseStreet fills the street-related fields of p from the leftover string
 // (the address with its house block removed).
+//
+// All recognised type tokens are removed from the name. This matters for
+// registry rows such as "Гусинобродский Тракт улица 21", where both "Тракт"
+// and "улица" are type-like: keeping either would mismatch a citizen who simply
+// says "Гусинобродский 21". The first type token becomes the canonical type.
+// If removing them would leave the name empty (a street literally called
+// "Набережная"), the type token is kept as the name.
 func parseStreet(p *ParsedAddress, s string) {
 	tokens := strings.Fields(s)
-	if len(tokens) == 0 {
-		p.StreetKey = streetKey("", "")
-		return
-	}
-
 	name := make([]string, 0, len(tokens))
-	typeFound := false
+	streetType := ""
+
 	for _, tok := range tokens {
-		// Only the first recognised type token is treated as the type; a
-		// second occurrence is part of the name.
-		if !typeFound {
-			if t, ok := streetTypes[tok]; ok {
-				p.StreetType = t
-				typeFound = true
-				continue
+		// Filler tokens ("г", "город", "дом", "область", ...) never belong to
+		// the street name.
+		if fillerWords[tok] {
+			continue
+		}
+		if t, ok := streetTypes[tok]; ok {
+			if streetType == "" {
+				streetType = t
 			}
+			continue
 		}
 		name = append(name, tok)
 	}
 
+	p.StreetType = streetType
+	if len(name) == 0 && streetType != "" {
+		name = []string{streetType}
+	}
+	if len(name) == 0 {
+		p.StreetKey = streetKey("", "")
+		return
+	}
+
 	name = extractOrdinal(p, name)
 	p.NameDisplay = strings.Join(name, " ")