perf: MergeFieldTermLocations fast-path + Reset nil-guard

Two micro-optimizations on per-scored-candidate hot paths:

- MergeFieldTermLocations (search/util.go): return early when no constituent
  match carries any FieldTermLocations (n == len(dest)). This is the common
  case with no highlighting / location tracking, and skips the second
  iteration and its per-match merge calls entirely.

- DocumentMatch.Reset (search/search.go): guard clear(scoreBreakdown) with a
  nil check. clear(nil) still dispatches through the Go map runtime (~1ns),
  and ScoreBreakdown is nil on the common path (no KNN, no score-breakdown
  retrieval).

Benchmark (search package, added here), Apple M4 Pro, count=12 via benchstat:

  MergeFieldTermLocations (no locations)    5.28ns -> 2.68ns   -49%  (p=0.000)
  DocumentMatch.Reset (nil ScoreBreakdown)  6.62ns -> 5.76ns   -13%  (p=0.000)

Absolute per-call costs are small, but both run per scored candidate (many
millions of calls per query), so they trim steady per-candidate overhead.
No allocation change.

Author: capemox

search/merge_reset_bench_test.go

@@ -0,0 +1,31 @@
+package search
+
+import "testing"
+
+// BenchmarkMergeFieldTermLocationsNoLocs: common no-highlighting case — several
+// constituent matches, none carrying field term locations. Exercises the
+// fast-path early return.
+func BenchmarkMergeFieldTermLocationsNoLocs(b *testing.B) {
+	matches := make([]*DocumentMatch, 5)
+	for i := range matches {
+		matches[i] = &DocumentMatch{}
+	}
+	b.ResetTimer()
+	b.ReportAllocs()
+	var dest []FieldTermLocation
+	for n := 0; n < b.N; n++ {
+		dest = MergeFieldTermLocations(nil, matches)
+	}
+	_ = dest
+}
+
+// BenchmarkDocumentMatchResetNilScoreBreakdown: Reset() on the common path where
+// ScoreBreakdown is nil. Exercises the clear(scoreBreakdown) nil-guard.
+func BenchmarkDocumentMatchResetNilScoreBreakdown(b *testing.B) {
+	dm := &DocumentMatch{}
+	b.ResetTimer()
+	b.ReportAllocs()
+	for n := 0; n < b.N; n++ {
+		dm.Reset()
+	}
+}

search/search.go

@@ -235,8 +235,12 @@ func (dm *DocumentMatch) Reset() *DocumentMatch {
 	}
 	// remember the score breakdown map
 	scoreBreakdown := dm.ScoreBreakdown
-	// clear out the score breakdown map
-	clear(scoreBreakdown)
+	// clear out the score breakdown map; nil-guard because clear(nil) still
+	// dispatches through the map runtime (~1ns), and ScoreBreakdown is nil on
+	// the common path (no KNN, no score-breakdown retrieval)
+	if scoreBreakdown != nil {
+		clear(scoreBreakdown)
+	}
 	// remember the Descendants backing array
 	descendants := dm.Descendants
 	for i := range descendants { // recycle each IndexInternalID

search/util.go

@@ -54,6 +54,9 @@ func MergeFieldTermLocations(dest []FieldTermLocation, matches []*DocumentMatch)
 			n += len(dm.FieldTermLocations)
 		}
 	}
+	if n == len(dest) {
+		return dest // fast path: no constituent has field term locations to merge
+	}
 	if cap(dest) < n {
 		dest = append(make([]FieldTermLocation, 0, n), dest...)
 	}