drt: FlexGC detailed-route performance (bit-identical)

[saurav-fermions]

Summary

Two constant-factor optimizations to FlexGC, the dominant detailed-route DRC cost. Routing output is byte-for-byte identical (DEF MD5 unchanged at 1 and 8 threads).

1. Per-layer fixed-corner cache — materialize each net's fixed-polygon vertex set once per layer into a hash set (collectPolygonCorners) and test corner membership with an O(1) lookup, instead of a full boost::polygon scanline reconstruction per corner. Predicate is identical (a point is a corner iff it equals a boundary/hole vertex). On aes, initNet_pins_polygonCorners_helper cumulative time ~20.7% -> ~2.5%.
2. Per-thread scratch reuse — replace per-call heap-allocated scratch vectors in the route-time DRC checker with thread_local reusable buffers (clear() + reuse capacity), across checkMetalSpacing_*, checkMetalCornerSpacing_main, bg2gtl, and the corner-collection path.

Testing

Built openroad; full drt regression suite passes (19/19, incl. golden log_compare). Routed DEF is bit-identical to baseline.

Notes

• Pure constant-factor optimizations; no routing/DRC behavior change.
• No src/sta change; no cross-repo dependency.

[gemini-code-assist]

Code Review

This pull request optimizes the GC initialization and checking phases by utilizing thread_local scratch buffers to avoid frequent vector allocations, and caching polygon corners in a hash set to enable O(1) lookups instead of repeated scanline reconstructions. The feedback suggests further optimizing the polygon corner cache by making it thread_local and persisting it across pins of the same net, clearing it only when the net changes.

[gemini-code-assist]

Currently, fixedCornerCache is local to initNet_pins_polygonCorners_helper, which is called once per pin. This means the cache is cleared and re-materialized for every single pin, even if multiple pins belong to the same net and share the same layer. Since the net's fixed polygon set (net->getPolygons(true)[layerNum]) is identical across all pins of the same net, we can optimize this further by making the cache thread_local and persisting it across pins of the same net, clearing it only when the net changes.

  thread_local gcNet* cachedNet = nullptr;
  thread_local std::map<frLayerNum,
                        std::unordered_set<std::pair<frCoord, frCoord>,
                                           boost::hash<std::pair<frCoord, frCoord>>>>
      fixedCornerCache;
  if (cachedNet != net) {
    fixedCornerCache.clear();
    cachedNet = net;
  }

[saurav-fermions]

Thanks for the review.

• Accidental src/sta bump: removed (force-pushed) — this PR no longer touches the submodule.
• gemini (fixedCornerCache scope): the cache is intentionally per-pin — it's built from the net's fixed-polygon vertex set on the pin's layers, and the O(scanline)→O(1) win is already realized per pin. Widening it to net scope is a reasonable follow-up but adds cross-pin lifetime/keying complexity for a smaller marginal gain; I've kept it local and bit-identical here.