Scrub SpanPrototype references from the SizingHint layer

SpanPrototype and SizingHint converge in a later PR; on this branch the hint is
a SizingHint keyed by operation name (SizingHintTable), so the illustrative
SpanPrototype mentions were misleading. Reword comments and rename the benchmark
field to sizingHint.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Author: dougqh

dd-trace-core/src/main/java/datadog/trace/core/DDSpanContext.java

@@ -139,11 +139,10 @@ public class DDSpanContext
    */
   private final TagMap unsafeTags;
 
-  // Per-type sizing hint (e.g. a SpanPrototype) this span was created from, if any. Held so the
-  // span
-  // can feed its final dense-store size back on finish (recordSize) -- the self-tuning loop that
-  // lets
-  // the reused hint converge to the type's real known-tag high-water mark. Null when unsized.
+  // Per-operation sizing hint (from SizingHintTable, keyed by operation name) this span was sized
+  // from, if any. Held so the span can feed its final dense-store size back on finish (recordSize)
+  // -- the self-tuning loop that lets the reused hint converge to the operation's real known-tag
+  // high-water mark. Null when unsized.
   private final SizingHint sizingHint;
 
   /** The service name is required, otherwise the span are dropped by the agent */
@@ -977,10 +976,9 @@ public void setTag(final String tag, final String value) {
   }
 
   /**
-   * Feeds this span's final dense-store size back into the sizing hint it was created from (if
-   * any). Called once at span finish; lets a reused hint (e.g. a per-type SpanPrototype) self-tune
-   * to the type's observed known-tag high-water mark, so subsequent spans of the type are sized
-   * correctly.
+   * Feeds this span's final dense-store size back into the sizingHint it was created from (if any).
+   * Called once at span finish; lets a reused hint self-tune to the operation's observed known-tag
+   * high-water mark, so subsequent spans of the operation are sized correctly.
    */
   void recordDenseSize() {
     if (sizingHint != null) {

internal-api/src/jmh/java/datadog/trace/api/DenseStoreAllocBenchmark.java

@@ -90,9 +90,9 @@ public class DenseStoreAllocBenchmark {
 
   private String[] keys;
   private String[] values;
-  // Per-type sizing hint seeded to this scenario's known-tag count -- what a SpanPrototype
+  // Per-operation sizing hint seeded to this scenario's known-tag count -- what SizingHintTable
   // supplies.
-  private SizingHint prototype;
+  private SizingHint sizingHint;
 
   @Setup(Level.Trial)
   public void setup() {
@@ -111,8 +111,8 @@ public void setup() {
       this.keys[i] = i < knownCount ? KNOWN[i] : "custom.tag." + i;
       this.values[i] = "value-" + i;
     }
-    // Size the dense store to the known-tag count (the "end state" per-type sizing).
-    this.prototype = new SizingHint("bench", 0, Math.max(knownCount, 1));
+    // Size the dense store to the known-tag count (the "end state" per-operation sizing).
+    this.sizingHint = new SizingHint("bench", 0, Math.max(knownCount, 1));
   }
 
   /** Current: generic default dense capacity (KNOWN_INIT_CAP=12) -- over-provisions small types. */
@@ -125,12 +125,10 @@ public TagMap buildMap() {
     return m;
   }
 
-  /**
-   * End state: dense store sized per-type via a SpanPrototype (SizingHint) -- no over-provision.
-   */
+  /** End state: dense store sized per-operation via a SizingHint -- no over-provision. */
   @Benchmark
   public TagMap buildMapSized() {
-    TagMap m = TagMap.create(prototype);
+    TagMap m = TagMap.create(sizingHint);
     for (int i = 0; i < tagCount; i++) {
       m.set(keys[i], values[i]);
     }

internal-api/src/main/java/datadog/trace/api/TagMap.java

@@ -1071,10 +1071,10 @@ public EntryChange next() {
    * <ul>
    *   <li><b>Tier 1 — group mask:</b> one bit per declaration group ({@code 1L << group-decl}). A
    *       clear group bit proves EVERY tag of that group is absent, so seeding a fresh group (e.g.
-   *       a {@code SpanPrototype} bulk insert) skips the scan for the whole group — the bulk-insert
-   *       payoff. Disjoint groups across two maps ({@code (a.knownGroupMask & b.knownGroupMask) ==
-   *       0}) prove nothing shadows across them, which the read-through shadow check exploits (see
-   *       {@link #parentDenseVisible}).
+   *       a bulk insert) skips the scan for the whole group — the bulk-insert payoff. Disjoint
+   *       groups across two maps ({@code (a.knownGroupMask & b.knownGroupMask) == 0}) prove nothing
+   *       shadows across them, which the read-through shadow check exploits (see {@link
+   *       #parentDenseVisible}).
    *   <li><b>Tier 2 — field bloom:</b> when the group bit clashes, fall back to one shared word
    *       over {@code field-decl & 63}. A clear field bit still proves absence; a clash falls
    *       through to the authoritative scan.