Implement RPCTransport on top of connect-go so the data source can dial
ConnectRPC subgraphs without changing the planner, compiler, or JSON
builder. NewConnectTransport accepts a base URL plus a wire format
(ConnectEncodingProtobuf "proto" or ConnectEncodingJSON "json"), an
optional HTTP client, and a slice of connect.Interceptor for tracing,
logging, retries, or auth header injection.

Each procedure is served by a cached connect.Client built around a
custom codec that binds dynamicpb.Message to the expected response
descriptor at unmarshal time; connect-go's default proto codec cannot
do this because it would allocate a descriptor-less *dynamicpb.Message.
The cache is intentionally unbounded because the set of procedures is
bounded by the data source schema.

Outgoing grpc/metadata is copied onto the Connect request headers using
the same conventions as the gRPC transport, with binary headers (the
"-bin" suffix) base64-encoded per the Connect spec. Errors are wrapped
with %w so callers can still errors.As the underlying *connect.Error
to inspect Code, Message, Details, and Metadata. The response is merged
into a reset output message to avoid accumulating repeated-field values
across invocations.

The RPCTransport interface contract is now documented in transport.go,
covering the methodFullName format ("/package.Service/Method") and the
input/output expectations that both gRPC and Connect implementations
share.

Tests cover protobuf and JSON wire formats, header passthrough
(including binary), error mapping, context cancellation, trailing-slash
BaseURL handling, and the HTTPClient: nil default-fallback path.

Dependencies: adds connectrpc.com/connect v1.19.2 and promotes
golang.org/x/net from indirect to direct.

Mirror the existing MockService end-to-end happy path, but route the
call through NewConnectTransport against an httptest server backed by
the buf-generated MockServiceConnect handler. Two tests cover the
protobuf and JSON wire formats; both prove that the full data source
pipeline (compiler -> JSON builder -> transport -> response unmarshal)
behaves identically over Connect, using the same fixture, schema, and
mapping as the gRPC path.

Expose the ConnectRPC transport (added in this PR's earlier commits) on
the GraphQL data source planner so subgraphs declared with a Connect
endpoint dial over the Connect transport instead of a gRPC client
connection.

- configuration.go: new ConnectConfiguration{BaseURL, Encoding} field on
  ConfigurationInput, plus a Connect != nil arm in the
  "fetch or subscription or grpc or connect" validation. Connect reuses
  the gRPC mapping/compiler for proto schema definitions, so the GRPC
  configuration is required even when only Connect will be dialed at
  runtime.

- graphql_datasource.go:
  * Planner and Factory carry a connectTransport field (RPCTransport).
  * The data source factory dispatches: connectTransport when set, else
    NewGRPCTransport(p.grpcClient). The dispatch sits inside the
    existing grpc != nil branch because both transports share the same
    mapping/compiler path; selection is per-Factory.
  * NewFactoryConnect constructor wires a Connect transport into the
    planner without requiring a gRPC client.
  * AlwaysFlattenFragments now also returns true when only a Connect
    transport is configured.
  * Error message switches from "failed to create gRPC datasource" to
    the transport-agnostic "failed to create datasource".

Addresses @Noroth's review comment on wundergraph#1509 about the wire-up step
living in graphql_datasource. The router-side configuration plumbing
will land in the follow-up cosmo PR.

…ration

Six unit tests pin the wiring contract introduced in the preceding feat
commit:

- NewFactoryConnect rejects a nil context or a nil transport.
- A Connect-backed Factory propagates its RPCTransport to every Planner
  it constructs and reports AlwaysFlattenFragments=true so the planner
  emits inline fields.
- NewConfiguration refuses a Connect-only ConfigurationInput, since
  Connect reuses the gRPC mapping/compiler.
- NewConfiguration accepts Connect when paired with GRPC and the
  resulting Configuration reports both IsGRPC() and IsConnect().
- The empty-configuration error message lists "connect" alongside the
  existing transports.

The full transport-level pipeline is already exercised in
pkg/engine/datasource/grpc_datasource/grpc_datasource_connect_test.go,
so these tests focus on the dispatch contract rather than duplicating
the end-to-end path.

…ruct

Bring the JSON-encoded happy-path test in line with the protobuf-encoded
one by unmarshalling the response into a typed struct and asserting on
the decoded fields, instead of using permissive substring checks against
the serialised bytes. A regression that emits a malformed or partially
correct payload would slip past the previous require.Contains assertions
but now triggers a clear failure.

Addresses coderabbitai nitpick on wundergraph#1509.

…IsConnect()

Per @Noroth's review on wundergraph#1509, simplify the transport selection to a
single switch on p.config.IsConnect():

  - Connect configuration -> require p.connectTransport, else hard error
  - otherwise (gRPC)      -> require p.grpcClient, else hard error

The Configuration is the declarative source of truth for which wire
protocol a subgraph uses; the factory must supply the matching
runtime resource. Mismatches now surface at plan time instead of
silently dialing the wrong protocol.

This replaces the prior factory-first ordering. Callers that
historically relied on "construct NewFactoryConnect, leave Connect
out of Configuration" must now populate ConnectConfiguration on the
data source configuration as well; the cosmo router PR will be
updated to do exactly that.

MockServiceConnect forwards Connect handler calls into the underlying
MockService, which reads request metadata via
metadata.FromIncomingContext. Connect carries headers on req.Header()
rather than on the ctx, so until now the inner service saw an empty
metadata.MD whenever a test driver attached X-User-ID / X-User-Prefix
etc. on the way in — the fixture was silently dropping every header
that arrived over ConnectRPC.

Introduce a small connectCtxToGRPC helper that copies req.Header() into
a metadata.MD on a fresh incoming-metadata context (lowercasing keys
the way grpc/metadata does), and apply it at the head of every
forward. The helper is a no-op when no headers are present, so the
existing happy-path tests are unaffected.

This unblocks the upcoming Connect e2e tests for headers and
context-metadata propagation.

…ect e2e tests

Pull the planner/transport/data-source scaffolding out of the existing
WithMockServiceConnect happy-path tests into a small helper so the
table-driven Connect tests that follow can focus on query, mapping,
and validation:

- connectE2E options struct collects the per-call knobs (BaseURL,
  Query, Vars, Ctx, Headers, Encoding, FederationConfigs). Zero-valued
  Ctx falls back to context.Background(), zero-valued Encoding falls
  back to ConnectEncodingProtobuf, and Headers/FederationConfigs to
  nil; callers only set what matters.
- loadConnectQuery wires those inputs through NewConnectTransport,
  NewDataSource(testMapping()), and ds.Load, returning the raw
  GraphQL response bytes.
- The original WithMockServiceConnect and WithMockServiceConnect_JSON
  tests collapse onto one table-driven function with proto and json
  subtests. They previously carried 30+ lines of hand-rolled GRPCMapping
  apiece; testMapping() is functionally a superset for these fields,
  so the assertions remain identical.

No behaviour change, no new test coverage. Net: ~150 lines removed.

…-case scenarios

Address @Noroth's request on wundergraph#1509 to broaden the ConnectRPC e2e
coverage beyond the original happy path. The new cases target points
where the gRPC and Connect transports diverge in code path, so the
tests pin the boundary where new Connect-specific bugs would surface
rather than re-test planner behaviour the gRPC suite already covers.

  - *UnionTypes              inline fragments through a union
                             (`... on Product | User | Category`),
                             single and list. Pins that __typename
                             narrowing still works when the wire is
                             Connect.
  - *FieldResolvers          a query that fans out into separate
                             Resolve<X> RPCs after the parent
                             Category loads. Pins that the data
                             source still merges multiple Connect
                             calls into one GraphQL response.
  - *Entities                Apollo Federation `_entities` lookup
                             with a mixed batch of Product/Storage
                             representations.
  - *AnimalInterface         interface types (proto oneof). Runs
                             both protobuf and protojson encodings
                             to pin that __typename narrowing works
                             either way.
  - *NullableFields          proto3 wrapper types (StringValue,
                             Int32Value, ...). protojson serialises
                             wrappers as bare values or null;
                             protobuf keeps them as messages. Both
                             encodings exercised.
  - *Headers                 metadata-to-HTTP-header translation:
                             the data source attaches an http.Header
                             on Load, the transport puts it on the
                             wire, and the subgraph echoes it back.
  - *PreservesContextMetadata  existing grpc/metadata in the caller's
                             context must reach the subgraph
                             alongside the per-call HTTP headers,
                             otherwise nested RPCs that rely on the
                             passed-through metadata silently break.
  - *Error                   Connect's HTTP-status-based error model
                             must still surface as a GraphQL errors
                             array, mirroring the gRPC-trailer case.
  - *NestedLists             repeated-field encoding under both
                             wires, including required-list-of-
                             optional-items and optional-list-of-
                             required-items shapes.

All built on the loadConnectQuery helper introduced in the preceding
refactor commit, so each test reads as query + validation rather than
transport scaffolding.