feat(bigtable): wire session.Client into Open* via TableShim - #20262

Follow-up on the diverter wiring in this PR. Makes Client.Open route
through the same TableShim path that OpenTable / OpenAuthorizedView /
OpenMaterializedView already use, without changing Open's *Table
return type — so classic callers that hold a concrete *Table pointer
(BulkMutation and any external code) will get session routing when the
session backend lands in a follow-up PR.

Wiring:
- Table gains a divertible TableAPI field. Nil for classic-only clients.
- Table.Apply / Table.ReadRow become one-line gates:
    if t.divertible != nil { return t.divertible.X(...) }
    return t.xClassic(...)
- Table.applyClassic / Table.readRowClassic hold the original bodies
  verbatim — no metrics / tracer / retry behavior change on classic.
- tableImpl grows an explicit ReadRow override; both tableImpl.Apply
  and tableImpl.ReadRow now call the *Classic helpers directly,
  bypassing the gate. This breaks the recursion loop: the shim's
  classic branch dispatches into tableImpl, which lands on applyClassic
  / readRowClassic instead of coming back through Table.Apply /
  Table.ReadRow.
- Open populates t.divertible via a new buildDivertible helper that
  constructs NewTableShim(&tableImpl{Table: <snapshot with divertible
  zeroed>}, nil, c.diverter) when c.diverter != nil. The
  snapshot-with-divertible-zeroed is defense in depth against a future
  reader who removes the tableImpl overrides.
- OpenTable / OpenAuthorizedView / OpenMaterializedView refactored to
  reuse buildDivertible so all four Open* methods construct the shim
  identically. Session TableAPI is nil today; the follow-up wires it.

Behavioral guarantees:
- Conditional Apply (CheckAndMutateRow) still routes to classic —
  TableShim.Apply enforces that on the shim side; the Table-level gate
  is unconditional so every conditional passes through the shim, which
  re-routes it to classic. Same end state.
- ReadRows / SampleRowKeys / ApplyBulk / ApplyReadModifyWrite are
  untouched — no session equivalent, no gate needed.
- Classic-only clients (c.diverter == nil) short-circuit at
  buildDivertible; Table.divertible stays nil; both gates fall through
  to *Classic on the fast path. Zero perf change.

All target tests green.

gemini review on PR googleapis#20256 flagged that pickSession would NPE if a
caller built a TableShim without a diverter (TableShim is exported, so
this is reachable from tests and external code even though in-repo
callers always wire one via NewTableShim).

Widens the short-circuit to `t.session == nil || t.diverter == nil`.
Nil-session guard still runs FIRST — same reason as before: consulting
the diverter is side-effectful (per-outcome pick counters), and we
don't want session picks that got downgraded to classic here inflating
the histogram.

…ableShim"

This reverts commit 5b48ef4.

…t-diverter-open

Folds PR googleapis#20258 into this PR. TableShim's session backend changes from
the classic-shaped TableAPI (row string + bigtable.Row) to the
internal/session.TableAPI shape (proto-native
*btpb.SessionReadRow{Request,Response} + *btpb.SessionMutateRow
{Request,Response}). TableShim owns the proto ↔ public-types
translation so the session package can stay proto-native.

- ReadRow: parses ReadOptions via classic makeReadSettings/readSettings
  so every existing option (RowFilter, WithFullReadStats, etc.) works
  on the session path; then translates
  (row, filter) → SessionReadRowRequest, calls session.ReadRow, feeds
  resp.Stats through WithFullReadStats, and converts resp.Row via
  protoRowToRow (added in googleapis#20257, now on main).
- Apply: nil mutations and conditional mutations (CheckAndMutateRow)
  route to classic — CheckAndMutateRow has no session vRPC equivalent,
  and nil-m to classic surfaces the classic client's existing
  nil-handling error rather than panicking on m.ops here.
- useSession() helper is nil-safe on both session and diverter
  (replaces the earlier pickSession); callers can wire a TableShim
  with nil session and every routing decision falls through to
  classic.

Signature change (internal-only): NewTableShim's session parameter
type is now session.TableAPI (an internal package). In-repo callers
pass nil for session today; nil is the zero value of any interface,
so the change is source-compatible for those.

Tests: replaces the mockTableAPI-as-session pattern with a
proto-native mockSessionTable. Covers routing, nil-session fallback,
session error propagation, conditional-always-classic, and the
already-existing TestProtoRowToRow contract.

Closes PR googleapis#20258 (the standalone version); folded here so PR googleapis#20256's
review scope is one coherent unit — Diverter wiring + TableShim
proto-native shape together.

…t-diverter-open

goimports flagged bigtable/client.go on CI. The Option B revert left
a double blank line where the four Open* methods used to sit; goimports
canonicalizes that to a single blank line. Pure whitespace fix.

Adds bigtable/open_test.go with 5 tests pinning the factory contract
introduced by this PR. Focused on the composition (which shape each
factory returns + how it wires the client's Diverter) rather than
re-testing routing behavior — TableShim's own tests already cover
nil-session-routes-to-classic
(TestTableShim_NilSession_AllMethodsFallBackToClassic on main).

Tests:
- TestOpen_ReturnsBareTable — Open returns plain *Table (no
  session-routing wrapper). Callers holding *Table stay on the
  classic path regardless of Client's diverter setting.
- TestOpenTable_ProducesNilSessionShim — OpenTable returns
  *TableShim with session == nil and classic == *tableImpl. Uses
  SessionLoad=1.0 on the diverter to prove useSession() still
  returns false because session is nil (the nil-session
  short-circuit runs before consulting the diverter).
- TestOpenAuthorizedView_ProducesNilSessionShim — same, plus
  authorizedView threaded through to the inner Table.
- TestOpenMaterializedView_ProducesNilSessionShim — same, plus
  materializedView threaded through (table empty since MVs are
  addressed by view name only).
- TestOpenFactories_ShareOneClientDiverter — every Open* factory
  references the SAME *Diverter, and mutating it via SetSessionLoad
  is visible from every shim (proves the reference is live, not a
  copy). This is the invariant a future
  ConfigurationManager.SetSessionLoad depends on to update every
  open resource at once.

Test bootstrap uses a hand-built minimal *Client (project +
appProfile + featureFlagsMD + diverter) rather than NewClientWithConfig
to keep the tests dial-free and hermetic — the factory code paths only
read those fields.

Follow-up to googleapis#20256 (Diverter wiring). Makes Open* actually produce
session-routed TableShims when the caller opts in via
ClientConfig.EnableSessionPool = true. Without the opt-in the shim's
session TableAPI stays nil and every routing decision falls through to
classic (existing behavior; existing tests still pass).

Wiring:

- Client gains three fields:
    sessionImpl     session.Client
    sessionTablesMu sync.Mutex
    sessionTables   map[string]session.TableAPI  // per-resource cache
- ClientConfig gains EnableSessionPool bool. When true,
  NewClientWithConfig calls session.NewClient(ctx, project, instance,
  appProfile, metricsProvider, opts...) with the same option set as
  the classic pool (endpoint/credentials/dial hooks match), then wires
  sc.AddSessionLoadListener(c.diverter.SetSessionLoad) so the
  server-driven ClientConfigurationManager can shift traffic across
  every open TableShim at once.
- If session.NewClient fails, the classic pool is closed and the whole
  NewClientWithConfig returns the error rather than leaking a
  half-constructed Client.
- Client.Close now closes sessionImpl (aggregating any error with the
  classic pool's Close error). Session backend closes FIRST — its
  ConfigurationManager poller and per-pool bookkeeping wind down
  before we drop the shared gRPC channels.
- open.go: three getOrCreateSession* helpers cache per-resource
  session TableAPIs. Cache keys are "tbl:<t>", "av:<t>:<v>" (table-
  qualified so same view-id under different tables gets distinct
  pools + distinct metric labels), "mv:<v>". session.Client itself
  does NOT cache — that's this Client's responsibility. Each helper
  nil-short-circuits when sessionImpl == nil so classic-only callers
  pay zero lock cost per Open call.
- OpenTable / OpenAuthorizedView / OpenMaterializedView now pass
  c.getOrCreateSession* result to NewTableShim instead of nil.

Tests (bigtable/open_test.go, +5 new):
- TestOpenTable_WithSessionBackend_WiresSessionTableAPI — verifies the
  shim carries a non-nil session TableAPI from sessionImpl.OpenTable.
- TestOpenTable_SessionTableAPICacheHit — two OpenTable calls on the
  same table return the same session TableAPI pointer (identity check);
  sessionImpl.OpenTable is called only once.
- TestOpenAuthorizedView_SessionCacheIsTableQualified — two AVs with
  the same view-id under DIFFERENT tables get DISTINCT session
  TableAPIs (defense against a bug where "av:<view>" would silently
  share pools across tables).
- TestOpenMaterializedView_WithSessionBackend_WiresSessionTableAPI —
  same shape as OpenTable, plus cache-hit assertion.
- TestGetOrCreateSession_NilSessionImplReturnsNil — every helper
  returns nil without taking the mutex when sessionImpl is nil.

Existing tests (nil-session shape) still pass; the earlier five
TestOpen* / TestOpenFactories tests validate the EnableSessionPool=false
default. Ten open-tests total, hermetic (no dial, no emulator).

gemini review flagged that the session.NewClient-failure cleanup path
called mPool.Pool.Close() directly, bypassing the ManagedChannelPool
wrapper. Switch to mPool.Close() so any wrapper-owned cleanup (metrics
reporter, connection recycler, dynamic scale monitor) also winds
down. Matches the shape used by (*Client).Close.

…SessionPool"

This reverts commit ea612a9.

Fixes the conformance regression from this PR. Root cause: the
conformance test proxy (bigtable/internal/testproxy/proxy.go:438-447)
pre-dials one *grpc.ClientConn and hands it to NewClientWithConfig via
option.WithGRPCConn(conn). Before this PR that was fine — the classic
pool was the only backend and it wrapped the single conn. My session
backend addition made session.NewClient ALSO wrap the same conn (opts
was reused verbatim), so both backends ended up entangled on the same
underlying transport. Any session-side teardown or config-poll failure
against the fake server propagated to the classic ClientConn as
"rpc error: code = Canceled desc = grpc: the client connection is
closing" on the very first Table.Apply.

Same bug hits BIGTABLE_EMULATOR_HOST paths because
internal/option.DefaultClientOptions injects WithGRPCConn internally
when that env var is set.

Fix: detect the WithGRPCConn sentinel via
internaloption.NewUnsafeResolver(opts...).ResolvedGRPCConnIsCustom()
and skip session backend construction entirely in that mode. Classic
path is unaffected — every RPC still lands on the pre-dialed conn as
before. sessionImpl stays nil; the existing nil-short-circuit in
getOrCreateSession* and Client.Close covers it.

Verified locally: bigtable conformance suite runs 64/0/0 pass/fail/skip
in 53s against v0.0.3 of cloud-bigtable-clients-test.

session.NewClient was receiving the raw caller opts instead of the
fully-merged option list (o). gtransport.Dial needs the
DefaultClientOptions merged in — endpoint, scopes, user-agent,
interceptors, connection-pool size, direct-access options — so
passing bare opts leaves the resolver target empty and the dial
aborts with 'passthrough: received empty target in Build()' as soon
as a caller invokes NewClientWithConfig without option.WithEndpoint.

Classic path was already using o for CreateAndStartManagedChannelPool
so this brings session into line and fixes end-to-end connectivity
against every prod endpoint pointed at by the default.