#3: close 3 known F1 gaps - folder/mailbox counters, quota-at-RCPT, alias fan-out

Per feature/3-f0-f1-validation's own gap analysis (commit 097fa37):

- InboundMessageRepository.Persist now updates folders.unread_count,
  folders.total_count, and mailboxes.used_bytes in the same transaction
  as the message insert (PLAN.md section 6.1 "++counters" was a no-op
  before this).
- MailboxRecord carries QuotaBytes/UsedBytes; ResolveRecipient rejects
  RCPT with 452 4.2.2 when a target mailbox has already reached its
  quota (used_bytes >= quota_bytes), before DATA - never silently
  accepting mail into a full mailbox.
- MailboxRepository.ResolveDeliveryTargets tries a direct mailbox match
  first, then falls back to the aliases table (exact source_address
  match takes precedence over a domain catch-all). One RCPT TO can now
  fan out to multiple mailboxes; alias destinations that don't resolve
  to an internal active mailbox are silently skipped, since outbound/
  external forwarding doesn't exist yet. postmaster@/abuse@/dmarc@-style
  aliases now actually deliver.

The E2E test's counters_updated subtest flips from a documented KNOWN
GAP (t.Skipf) to a hard assertion now that it passes, and gains two new
subtests (quota_rejected_when_mailbox_full, alias_resolves_to_destination_mailbox)
covering the other two fixes end-to-end. New unit and Postgres
integration test coverage added for all three fixes at every layer.

Verified: full suite green on Windows (unit + E2E via embedded
Postgres, no Docker needed) and via WSL Docker against the real
docker-compose Postgres (all infrastructure/postgres and diskstorage
integration tests, not just E2E). lang-lint clean.

services/protocols/internal/presentation/smtp/backend.go

@@ -61,23 +61,35 @@ func (s *session) Rcpt(to string, _ *gosmtp.RcptOptions) error {
 		}
 	}
 
-	rec, err := s.useCase.ResolveRecipient(context.Background(), to)
+	targets, err := s.useCase.ResolveRecipient(context.Background(), to)
 	if err != nil {
-		if errors.Is(err, usecase.ErrRecipientNotFound) {
+		switch {
+		case errors.Is(err, usecase.ErrRecipientNotFound):
 			return &gosmtp.SMTPError{
 				Code:         550,
 				EnhancedCode: gosmtp.EnhancedCode{5, 1, 1},
 				Message:      "User unknown",
 			}
-		}
-		return &gosmtp.SMTPError{
-			Code:         451,
-			EnhancedCode: gosmtp.EnhancedCode{4, 3, 0},
-			Message:      "Temporary error resolving recipient",
+		case errors.Is(err, usecase.ErrMailboxQuotaExceeded):
+			return &gosmtp.SMTPError{
+				Code:         452,
+				EnhancedCode: gosmtp.EnhancedCode{4, 2, 2},
+				Message:      "Mailbox full",
+			}
+		default:
+			return &gosmtp.SMTPError{
+				Code:         451,
+				EnhancedCode: gosmtp.EnhancedCode{4, 3, 0},
+				Message:      "Temporary error resolving recipient",
+			}
 		}
 	}
-	s.recipients = append(s.recipients, *rec)
-	s.recipientAddresses = append(s.recipientAddresses, to)
+	// One RCPT TO can resolve to multiple mailboxes (alias fan-out) - each
+	// gets its own delivery, all recorded under the same envelope address.
+	for _, rec := range targets {
+		s.recipients = append(s.recipients, rec)
+		s.recipientAddresses = append(s.recipientAddresses, to)
+	}
 	return nil
 }