Build per-tenant ClickHouse write-routing for ingest (Tantivy still deferred)

ingest tags every record with a tenant_id Kafka header (built previously),
but nothing consumed it to actually route the write. This closes that for
ClickHouse: enterprise/cmd/enterprise-ingest (a second binary, mirroring
enterprise-api) reuses ingest/consumer's own flush loop unchanged, with
enterprise/internal/chwriter.Registry -- a per-tenant clickhousewriter.Writer
registry -- swapped in as the writer. A batch pulled from the single shared
Redpanda topic can mix records from many tenants, so WriteBatch groups by
TenantID and dispatches each group to its own tenant's connection, fail-
closed on an empty or unrecognized tenant_id.

ingest/consumer and ingest/clickhousewriter move out of internal/ (same
reason api/internal/* moved earlier this phase: enterprise/ can't import
anything under another module's internal/). Their New() constructors now
take small local Config structs instead of ingest/internal/config types,
so enterprise/ doesn't need that import either.

Building this surfaced a real bug: tenantprovision.ProvisionClickHouse
only granted SELECT on a tenant's ClickHouse user, correct for chrunner's
read-only use but not enough for chwriter reusing the same credential to
write -- every real per-tenant write would have failed closed with a
permission error. Fixed by widening the grant to SELECT, INSERT; no
cross-tenant boundary is crossed by also allowing INSERT within a
tenant's own database.

Helm gates enterprise-ingest's Deployment on the same
ingest.requireTenantCredential flag that already gates tag validation --
write-routing is meaningless without tagging already being required, so
they're one decision, not two. docker-compose.yml's version is a
disclosed, weaker approximation: it can't achieve Helm's genuine
-mode=server/-mode=consumer split, so with the enterprise profile active
both ingest and enterprise-ingest independently consume every message
via different consumer groups -- harmless duplication for local
verification only.

Not built: Tantivy's independent Redpanda consumer (search/src/consumer.rs)
still doesn't read the tenant_id header at all -- every record still lands
in the one shared index regardless of tenant. Not run: the live-ClickHouse-
gated tests (chwriter's cross-tenant routing test, tenantprovision's INSERT
regression test) -- no Docker/database access in this environment; they're
correct Go that has never executed, disclosed as such in docs/security/
threat-model.md and docs/phase-4-runbook.md §14.

ingest/cmd/ingest/main.go

@@ -21,14 +21,36 @@ import (
 
 	"golang.org/x/sync/errgroup"
 
-	"github.com/sentry/sentry/ingest/internal/clickhousewriter"
+	"github.com/sentry/sentry/ingest/clickhousewriter"
+	"github.com/sentry/sentry/ingest/consumer"
 	"github.com/sentry/sentry/ingest/internal/config"
-	"github.com/sentry/sentry/ingest/internal/consumer"
 	"github.com/sentry/sentry/ingest/internal/grpcserver"
 	"github.com/sentry/sentry/ingest/internal/producer"
 	"github.com/sentry/sentry/ingest/internal/tenantresolver"
+	logsv1 "github.com/sentry/sentry/proto/sentry/logs/v1"
 )
 
+// singleTenantWriter adapts *clickhousewriter.Writer -- which only
+// knows how to write to the one ClickHouse database it was constructed
+// with -- to consumer.chWriter's tenant-tagged signature, by simply
+// ignoring the tag. This is this binary's single-tenant behavior,
+// unchanged from before per-tenant ingest credentials existed: every
+// record lands in the same shared database regardless of which tenant
+// (if any) it was resolved to. enterprise/cmd/enterprise-ingest is
+// where a tag-respecting writer (enterprise/internal/chwriter.Registry)
+// actually routes per tenant instead.
+type singleTenantWriter struct {
+	w *clickhousewriter.Writer
+}
+
+func (s singleTenantWriter) WriteBatch(ctx context.Context, records []consumer.Record) error {
+	plain := make([]*logsv1.LogRecord, len(records))
+	for i, r := range records {
+		plain[i] = r.Record
+	}
+	return s.w.WriteBatch(ctx, plain)
+}
+
 func main() {
 	mode := flag.String("mode", "all", "which half of ingest to run: server | consumer | all")
 	flag.Parse()
@@ -70,13 +92,19 @@ func main() {
 	}
 
 	if *mode == "consumer" || *mode == "all" {
-		chw, err := clickhousewriter.New(ctx, cfg.ClickHouse)
+		chw, err := clickhousewriter.New(ctx, clickhousewriter.Config{
+			Addr: cfg.ClickHouse.Addr, Database: cfg.ClickHouse.Database,
+			Username: cfg.ClickHouse.Username, Password: cfg.ClickHouse.Password,
+		})
 		if err != nil {
 			logger.Error("connecting to clickhouse", "error", err)
 			os.Exit(1)
 		}
 		defer chw.Close()
-		c := consumer.New(logger, cfg.Redpanda, cfg.Batch, chw)
+		c := consumer.New(logger, consumer.Config{
+			Brokers: cfg.Redpanda.Brokers, Topic: cfg.Redpanda.Topic, ConsumerGroup: cfg.Redpanda.ConsumerGroup,
+			BatchMaxSize: cfg.Batch.MaxSize, FlushIntervalMS: cfg.Batch.FlushIntervalMS,
+		}, singleTenantWriter{w: chw})
 		g.Go(func() error { return c.Run(ctx) })
 	}