net/tsaddr: use bart in NewContainsIPFunc, add tests, benchmarks

NewContainsIPFunc was previously documented as performing poorly if
there were many netip.Prefixes to search over. As such, we never it used it
in such cases.

This updates it to use bart at a certain threshold (over 6 prefixes,
currently), at which point the bart lookup overhead pays off.

This is currently kinda useless because we're not using it. But now we
can and get wins elsewhere. And we can remove the caveat in the docs.

    goos: darwin
    goarch: arm64
    pkg: tailscale.com/net/tsaddr
                                     │    before    │                after                 │
                                     │    sec/op    │    sec/op     vs base                │
    NewContainsIPFunc/empty-8          2.215n ± 11%   2.239n ±  1%   +1.08% (p=0.022 n=10)
    NewContainsIPFunc/cidr-list-1-8    17.44n ±  0%   17.59n ±  6%   +0.89% (p=0.000 n=10)
    NewContainsIPFunc/cidr-list-2-8    27.85n ±  0%   28.13n ±  1%   +1.01% (p=0.000 n=10)
    NewContainsIPFunc/cidr-list-3-8    36.05n ±  0%   36.56n ± 13%   +1.41% (p=0.000 n=10)
    NewContainsIPFunc/cidr-list-4-8    43.73n ±  0%   44.38n ±  1%   +1.50% (p=0.000 n=10)
    NewContainsIPFunc/cidr-list-5-8    51.61n ±  2%   51.75n ±  0%        ~ (p=0.101 n=10)
    NewContainsIPFunc/cidr-list-10-8   95.65n ±  0%   68.92n ±  0%  -27.94% (p=0.000 n=10)
    NewContainsIPFunc/one-ip-8         4.466n ±  0%   4.469n ±  1%        ~ (p=0.491 n=10)
    NewContainsIPFunc/two-ip-8         8.002n ±  1%   7.997n ±  4%        ~ (p=0.697 n=10)
    NewContainsIPFunc/three-ip-8       27.98n ±  1%   27.75n ±  0%   -0.82% (p=0.012 n=10)
    geomean                            19.60n         19.07n         -2.71%

Updates #12486

Change-Id: I2e2320cc4384f875f41721374da536bab995c1ce
Signed-off-by: Brad Fitzpatrick <bradfitz@tailscale.com>

net/tsaddr/tsaddr.go

@@ -11,6 +11,7 @@ import (
 	"slices"
 	"sync"
 
+	"github.com/gaissmai/bart"
 	"go4.org/netipx"
 	"tailscale.com/net/netaddr"
 	"tailscale.com/types/views"
@@ -165,6 +166,10 @@ func FalseContainsIPFunc() func(ip netip.Addr) bool {
 	return func(ip netip.Addr) bool { return false }
 }
 
+// pathForTest is a test hook for NewContainsIPFunc, to test that it took the
+// right construction path.
+var pathForTest = func(string) {}
+
 // NewContainsIPFunc returns a func that reports whether ip is in addrs.
 //
 // It's optimized for the cases of addrs being empty and addrs
@@ -176,32 +181,50 @@ func NewContainsIPFunc(addrs views.Slice[netip.Prefix]) func(ip netip.Addr) bool
 	// Specialize the three common cases: no address, just IPv4
 	// (or just IPv6), and both IPv4 and IPv6.
 	if addrs.Len() == 0 {
+		pathForTest("empty")
 		return func(netip.Addr) bool { return false }
 	}
-	// If any addr is more than a single IP, then just do the slow
-	// linear thing until
-	// https://github.com/inetaf/netaddr/issues/139 is done.
+	// If any addr is a prefix with more than a single IP, then do either a
+	// linear scan or a bart table, depending on the number of addrs.
 	if addrs.ContainsFunc(func(p netip.Prefix) bool { return !p.IsSingleIP() }) {
-		acopy := addrs.AsSlice()
-		return func(ip netip.Addr) bool {
-			for _, a := range acopy {
-				if a.Contains(ip) {
-					return true
-				}
+		if addrs.Len() > 6 {
+			pathForTest("bart")
+			// Built a bart table.
+			t := &bart.Table[struct{}]{}
+			for i := range addrs.Len() {
+				t.Insert(addrs.At(i), struct{}{})
+			}
+			return func(ip netip.Addr) bool {
+				_, ok := t.Get(ip)
+				return ok
+			}
+		} else {
+			pathForTest("linear-contains")
+			// Small enough to do a linear search.
+			acopy := addrs.AsSlice()
+			return func(ip netip.Addr) bool {
+				for _, a := range acopy {
+					if a.Contains(ip) {
+						return true
+					}
+				}
+				return false
 			}
-			return false
 		}
 	}
 	// Fast paths for 1 and 2 IPs:
 	if addrs.Len() == 1 {
+		pathForTest("one-ip")
 		a := addrs.At(0)
 		return func(ip netip.Addr) bool { return ip == a.Addr() }
 	}
 	if addrs.Len() == 2 {
+		pathForTest("two-ip")
 		a, b := addrs.At(0), addrs.At(1)
 		return func(ip netip.Addr) bool { return ip == a.Addr() || ip == b.Addr() }
 	}
 	// General case:
+	pathForTest("ip-map")
 	m := map[netip.Addr]bool{}
 	for i := range addrs.Len() {
 		m[addrs.At(i).Addr()] = true