Add Protocol Buffers and gRPC compiler

[OmarAlJarrah]

Summary

Adds compilers/protobuf, a compiler that lowers Protocol Buffers .proto
schemas into Morphic's spec-agnostic IR — the protobuf/gRPC counterpart to the
existing OpenAPI compiler. Parsing uses github.com/bufbuild/protocompile, a
pure-Go .proto compiler that produces fully linked, feature-resolved
descriptors and bundles the well-known-type imports. Like every compiler, it
does no file I/O: it compiles a single root .proto supplied as bytes, resolves
google/protobuf/*.proto imports from the parser's bundle, and reports any other
unresolved import as a diagnostic rather than crashing.

It supports proto2, proto3, and the 2023 edition through one lowering, since the
parser resolves edition features into the same descriptor surface the
proto2/proto3 paths expose. The mapping onto the IR:

• Types. Messages, nested messages, and enums hoist into the flat, ID-keyed
  type registry, with IDs derived from their fully-qualified proto names (the
  stable structural identity, never a display name). Field numbers become
  Property.WireID; the package becomes Namespace.
• Presence. proto2 required/optional, proto3 implicit vs optional, and
  editions field_presence lower to Property.Presence
  (implicit/explicit/required). Protobuf has no null, so TypeRef.Nullable stays
  off and presence carries the three-state discipline on its own axis.
• oneof. A real oneof becomes a WireTagged, exclusive Union reached
  through one synthetic Flatten wrapper property, with each member's field
  number preserved as the variant wire ID. Synthetic proto3-optional oneofs
  are presence markers and stay ordinary fields, never unions.
• Containers & encodings. repeated hoists a List (packed vs expanded on
  List.Encoding); map<K,V> hoists a MapT without exposing the synthetic
  map-entry message; sint/fixed/sfixed lower to an Encoding over the base
  primitive; groups/editions DELIMITED carry the delimited encoding.
• Enums. Open vs closed follows the resolved semantics (proto2 closed, proto3
  open, per-enum editions feature); allow_alias duplicate values survive as
  distinct members.
• Well-known types. Timestamp/Duration map to date-time primitives;
  Any/Struct/Value to the schemaless Any node; the wrapper types to a
  nullable primitive by default (or an External under an injectable policy
  option); FieldMask/Empty to External. Well-known internals are never
  hoisted.
• Extensions & reserved. extend fields attach to the extended Model with
  Property.ExtensionOf; extensions ranges become Model.ExtensionRanges;
  reserved numbers/names and custom options (protovalidate and the like) are
  preserved verbatim in Extensions, guarded by the validate pass. Custom
  options render deterministically.
• Services. Each proto service becomes an OperationGroup; each rpc an
  Operation with a gRPC RPCBinding, streaming direction (unary, client,
  server, bidi), and idempotency level. An Empty request or response lowers to
  an absent payload.

No IR structs were changed: everything maps onto the existing IR, which already
accounts for wire IDs, oneof, packed repeated, extension ranges, presence, and
editions. One minor, documented degradation: a non-finite proto2 default
(inf/nan) is dropped with an info diagnostic rather than stored as an
invalid decimal, and a delimited group encoding in a nested (repeated/oneof)
position is not re-expressed on the wrapped element.

The compiler is not yet wired into the engine's default registry: engine.Sniff
is YAML/JSON-based and would need a content-detection path for .proto, which is
a separate engine-layer change. The compiler is fully usable through its public
API and registers cleanly into any compilers.Registry.

Test plan

• Conformance corpus — one minimal .proto per protobuf/gRPC capability from
  the cross-spec matrix under testdata/conformance/protobuf/, each with a
  focused capability assertion plus a byte-exact golden IR snapshot: messages,
  nested types, open/closed enums, oneof, proto3 optional, maps, packed/expanded
  repeated, scalar wire encodings, proto2 presence and defaults, extensions,
  reserved, packages, well-known types, all four streaming modes with
  idempotency, deprecation, doc comments, custom options, and a 2023-edition
  file.
• Golden snapshot — a full gRPC library service (testdata/golden/protobuf/).
• Round-trip property — compile, marshal, unmarshal, cmp.Diff-equal, and
  re-marshal for determinism.
• Registry / options / errors — format registration, the wrapper-external
  policy, unresolved-import diagnostics, wrong-options and multi-source rejection.
• Architecture test — extended so compilers/protobuf may import ir,
  compilers, protocompile, and the protobuf runtime only.

go build ./..., go vet ./..., gofmt -l . (clean), golangci-lint run
(clean), and go test ./... all pass.