perf: specialized score-descending comparator for top-N collector

SortOrder.Compare is called on every heap comparison and on every
lowestMatchOutsideResults / searchAfter check in the top-N collector. The
generic path iterates the sort-field slice and checks two bool flags
(cachedScoring, cachedDesc) per call, adding overhead to what is usually a
single float64 comparison.

Detect the overwhelmingly common case at collector-construction time — a
single score-descending sort — and store a specialized comparator (hc.cmp)
that compares Score directly, with HitNumber as the tie-break. Share it
across the heap store, the lowestMatchOutsideResults fast-path, and
searchAfter pagination. Falls back to the generic SortOrder.Compare for any
other sort order.

Extracted from a larger change; the companion collectStoreHeap.Final
sort.Slice optimization depended on the ternary-heap rework and is not
included here.

Benchmark (BenchmarkTop{K}of{N}Scores, search/collector, score-descending),
parent vs this commit, Apple M4 Pro, count=10 via benchstat:

  Top100of10000    -15.0%
  Top1000of100000  -13.5%
  Top1000of10000   -13.1%
  Top100of100000   -11.2%
  Top10of10000     -10.5%
  Top10of100000    ~ (noisy, not significant)
  geomean          -11.6%

Consistent ~11-15% collector speedup for score-sorted queries (the common
case), no meaningful allocation change.

Author: capemox

search/collector/topn.go

@@ -66,6 +66,7 @@ type TopNCollector struct {
 	facetsBuilder *search.FacetsBuilder
 
 	store collectorStore
+	cmp   collectorCompare // specialized or generic; shared by heap + dmHandler
 
 	needDocIds    bool
 	neededFields  []string
@@ -132,9 +133,38 @@ func NewNestedTopNCollectorAfter(size int, sort search.SortOrder, after []string
 func newTopNCollector(size int, skip int, sort search.SortOrder, nr index.NestedReader) *TopNCollector {
 	hc := &TopNCollector{size: size, skip: skip, sort: sort}
 
-	hc.store = getOptimalCollectorStore(size, skip, func(i, j *search.DocumentMatch) int {
-		return hc.sort.Compare(hc.cachedScoring, hc.cachedDesc, i, j)
-	})
+	// Compute once up-front; comparator and store creation need them.
+	hc.neededFields = sort.RequiredFields()
+	hc.cachedScoring = sort.CacheIsScore()
+	hc.cachedDesc = sort.CacheDescending()
+
+	// Specialize for the common case: single score-descending sort.
+	// SortOrder.Compare iterates a slice and checks two bool flags per call,
+	// adding ~40% overhead to every heap comparison. The direct float64 path
+	// eliminates that overhead; measured at ~18% of total CPU for k=1000 queries.
+	if len(sort) == 1 && hc.cachedScoring[0] && hc.cachedDesc[0] {
+		hc.cmp = func(i, j *search.DocumentMatch) int {
+			if i.Score < j.Score {
+				return 1 // i is worse (lower score → closer to heap root)
+			}
+			if i.Score > j.Score {
+				return -1
+			}
+			if i.HitNumber > j.HitNumber {
+				return 1 // tie-break: earlier hit is better
+			}
+			if i.HitNumber < j.HitNumber {
+				return -1
+			}
+			return 0
+		}
+	} else {
+		hc.cmp = func(i, j *search.DocumentMatch) int {
+			return hc.sort.Compare(hc.cachedScoring, hc.cachedDesc, i, j)
+		}
+	}
+
+	hc.store = getOptimalCollectorStore(size, skip, hc.cmp)
 
 	if nr != nil {
 		descAdder := func(parent, child *search.DocumentMatch) error {
@@ -163,13 +193,9 @@ func newTopNCollector(size int, skip int, sort search.SortOrder, nr index.Nested
 		hc.nestedStore = newStoreNested(nr, search.DescendantAdderCallbackFn(descAdder))
 	}
 
-	// these lookups traverse an interface, so do once up-front
 	if sort.RequiresDocID() {
 		hc.needDocIds = true
 	}
-	hc.neededFields = sort.RequiredFields()
-	hc.cachedScoring = sort.CacheIsScore()
-	hc.cachedDesc = sort.CacheDescending()
 
 	return hc
 }
@@ -561,7 +587,7 @@ func MakeTopNDocumentMatchHandler(
 				// exact sort order matches use hit number to break tie
 				// but we want to allow for exact match, so we pretend
 				hc.searchAfter.HitNumber = d.HitNumber
-				if hc.sort.Compare(hc.cachedScoring, hc.cachedDesc, d, hc.searchAfter) <= 0 {
+				if hc.cmp(d, hc.searchAfter) <= 0 {
 					ctx.DocumentMatchPool.Put(d)
 					return nil
 				}
@@ -571,9 +597,7 @@ func MakeTopNDocumentMatchHandler(
 			// with this one comparison, we can avoid all heap operations if
 			// this hit would have been added and then immediately removed
 			if hc.lowestMatchOutsideResults != nil {
-				cmp := hc.sort.Compare(hc.cachedScoring, hc.cachedDesc, d,
-					hc.lowestMatchOutsideResults)
-				if cmp >= 0 {
+				if hc.cmp(d, hc.lowestMatchOutsideResults) >= 0 {
 					// this hit can't possibly be in the result set, so avoid heap ops
 					ctx.DocumentMatchPool.Put(d)
 					return nil
@@ -585,8 +609,7 @@ func MakeTopNDocumentMatchHandler(
 				if hc.lowestMatchOutsideResults == nil {
 					hc.lowestMatchOutsideResults = removed
 				} else {
-					cmp := hc.sort.Compare(hc.cachedScoring, hc.cachedDesc,
-						removed, hc.lowestMatchOutsideResults)
+					cmp := hc.cmp(removed, hc.lowestMatchOutsideResults)
 					if cmp < 0 {
 						tmp := hc.lowestMatchOutsideResults
 						hc.lowestMatchOutsideResults = removed