Use gtl::InlinedVector to avoid heap allocations when serializing, hashing,...

Use gtl::InlinedVector to avoid heap allocations when serializing, hashing, and comparing small protocol buffers.

Benchmark numbers for serialization:

name                                          old time/op             new time/op             delta
BM_ProtoSerializationToBuffer/1                74.8ns ? 0%             60.3ns ? 0%   -19.41%          (p=0.008 n=5+5)
BM_ProtoSerializationToBuffer/8                 361ns ? 0%              346ns ? 0%    -4.20%          (p=0.016 n=5+4)
BM_ProtoSerializationToBuffer/64              2.57?s ? 0%             2.55?s ? 1%    -1.05%          (p=0.016 n=4+5)
BM_ProtoSerializationToBuffer/512             20.4?s ? 0%             20.5?s ? 1%      ~             (p=0.841 n=5+5)
BM_ProtoSerializationToBuffer/4k               173?s ? 2%              170?s ? 2%      ~             (p=0.095 n=5+5)
BM_ProtoSerializationToBuffer/10k              432?s ? 1%              420?s ? 0%    -2.85%          (p=0.008 n=5+5)

name                                          old allocs/op           new allocs/op           delta
BM_ProtoSerializationToBuffer/1                  1.00 ? 0%              0.00 ?NaN%  -100.00%          (p=0.008 n=5+5)
BM_ProtoSerializationToBuffer/8                  1.00 ? 0%              0.00 ?NaN%  -100.00%          (p=0.008 n=5+5)
BM_ProtoSerializationToBuffer/64                 1.00 ? 0%              0.00 ?NaN%  -100.00%          (p=0.008 n=5+5)
BM_ProtoSerializationToBuffer/512                1.00 ? 0%               1.00 ? 0%      ~     (all samples are equal)
BM_ProtoSerializationToBuffer/4k                 1.00 ? 0%               1.00 ? 0%      ~     (all samples are equal)
BM_ProtoSerializationToBuffer/10k                1.00 ? 0%               1.00 ? 0%      ~     (all samples are equal)

name                                          old peak-mem(Bytes)/op  new peak-mem(Bytes)/op  delta
BM_ProtoSerializationToBuffer/1                  36.0 ? 0%               36.0 ? 0%      ~     (all samples are equal)
BM_ProtoSerializationToBuffer/8                   112 ? 0%                 36 ? 0%   -67.86%          (p=0.008 n=5+5)
BM_ProtoSerializationToBuffer/64                  950 ? 0%                 37 ? 0%   -96.11%          (p=0.008 n=5+5)
BM_ProtoSerializationToBuffer/512               8.08k ? 0%              8.08k ? 0%      ~     (all samples are equal)
BM_ProtoSerializationToBuffer/4k                68.5k ? 0%              68.5k ? 0%      ~     (all samples are equal)
BM_ProtoSerializationToBuffer/10k                169k ? 0%               169k ? 0%      ~     (all samples are equal)

Benchmark numbers for hashing and comparison.
BM_DeterministicProtoHash64/1            278       260     +6.5%
BM_DeterministicProtoHash64/8           1969      1976     -0.4%
BM_DeterministicProtoHash64/64         16021     16043     -0.1%
BM_DeterministicProtoHash64/512       127188    127400     -0.2%
BM_DeterministicProtoHash64/4k       1089472   1104291     -1.4%
BM_DeterministicProtoHash64/10k      2594413   2621487     -1.0%
BM_AreSerializedProtosEqual/1            535       514     +3.9%
BM_AreSerializedProtosEqual/8           3853      3849     +0.1%
BM_AreSerializedProtosEqual/64         31212     31121     +0.3%
BM_AreSerializedProtosEqual/512       249554    249010     +0.2%
BM_AreSerializedProtosEqual/4k       2096963   2133310     -1.7%
BM_AreSerializedProtosEqual/10k      5027297   5100622     -1.5%

PiperOrigin-RevId: 233106678