fix(usage): use nearest-rank for latency percentiles (#1764)

## Bug

`ToolUsage.Percentile` computes the target rank as `int64(float64(total)
* p)`, which truncates. The nearest-rank method needs `ceil`. For small
call counts the p95/p99 lands one rank too low, so the slowest call
never shows up in the tail percentile. The Usage view (`GET
/api/v1/activity/usage`, `httpapi/activity.go`) reports exactly these
values as the tool's p95.

## Trigger

One tool receives 9 calls at ~30 ms and 1 call at 3000 ms.

- Expected p95: nearest rank `ceil(9.5) = 10`, which is the 3000 ms
call, so the bucket bound is ≤ 5000 ms.
- Actual: rank `int(9.5) = 9`, so p95 is ≤ 50 ms. The slow call is
invisible.

## Fix

Use `math.Ceil` for the target rank. The existing `target < 1` clamp is
kept, and large totals are unaffected, because the existing 100-call
tests still pass.

## Test

`TestToolUsagePercentile_SmallTotalsUseNearestRank` covers the 9-fast +
1-slow case above. It asserts p95 = 5000 (the bucket that holds 3000 ms)
and p50 = 50.

## Commands run

- `CGO_ENABLED=0 go test -count=1 ./internal/runtime`: ok
- `CGO_ENABLED=0 go test -count=1 -run 'Usage|Percentile'
./internal/httpapi`: ok
- With the fix reverted (`git stash` of `usage_aggregate.go`), the new
test fails with `p95 = 50 ms, want 5000`.
- `gofmt -l` on the edited files: no output

Author: rudycelekli

internal/runtime/usage_aggregate.go

@@ -1,6 +1,7 @@
 package runtime
 
 import (
+	"math"
 	"sort"
 	"strings"
 	"sync"
@@ -119,7 +120,9 @@ func (t *ToolUsage) Percentile(p float64) (ms int64, exceeds bool) {
 	if total == 0 {
 		return 0, false
 	}
-	target := int64(float64(total) * p)
+	// Nearest-rank: truncating would land one rank low for small totals and
+	// hide the slow tail (9 fast calls + 1 slow one would report p95 as fast).
+	target := int64(math.Ceil(float64(total) * p))
 	if target < 1 {
 		target = 1
 	}

internal/runtime/usage_percentile_rank_test.go

@@ -0,0 +1,20 @@
+package runtime
+
+import "testing"
+
+// Nearest-rank p95 of 10 calls is the 10th fastest (ceil(9.5)); truncating to
+// rank 9 reported nine fast calls plus one 3 s call as a ~30 ms p95.
+func TestToolUsagePercentile_SmallTotalsUseNearestRank(t *testing.T) {
+	tu := &ToolUsage{LatencyBuckets: make([]int64, len(latencyBucketBoundsMs)+1)}
+	for i := 0; i < 9; i++ {
+		tu.LatencyBuckets[latencyBucketIndex(30)]++
+	}
+	tu.LatencyBuckets[latencyBucketIndex(3000)]++
+
+	if got, _ := tu.Percentile(0.95); got != 5000 {
+		t.Errorf("p95 = %d ms, want 5000 (bucket holding the 3000 ms call)", got)
+	}
+	if got, _ := tu.Percentile(0.50); got != 50 {
+		t.Errorf("p50 = %d ms, want 50", got)
+	}
+}