test(tm2/pkg/cmap): adds benchmarks to show true impact of contention

The Go standard library's sync.Map is touted as great for cases with
high load and is commonly known knowledge but the benchmark that I am
committing shows otherwise that for this library's usage, it is so much
more expensive hence this benchmark will avoid someone committing
sync.Map without seeing the true implications.

```shell
$ benchstat map_w_mutex.txt stdlib_sync_map.txt
name                               old time/op    new time/op    delta
CMapConcurrentInsertsDeletesHas-8     1.72s ±11%     1.92s ± 3%   +11.66%  (p=0.000 n=10+9)
CMapHas-8                             109ns ± 9%     118ns ± 3%    +8.26%  (p=0.002 n=10+8)

name                               old alloc/op   new alloc/op   delta
CMapConcurrentInsertsDeletesHas-8    1.18GB ± 2%    3.21GB ± 3%  +172.09%  (p=0.000 n=10+10)
CMapHas-8                             16.0B ± 0%     16.0B ± 0%      ~     (all equal)

name                               old allocs/op  new allocs/op  delta
CMapConcurrentInsertsDeletesHas-8      824k ± 0%     4433k ± 0%  +437.89%  (p=0.000 n=10+10)
CMapHas-8                              2.00 ± 0%      1.60 ±38%      ~     (p=0.065 n=9+10)
```

Updates gnolang#3505

tm2/pkg/cmap/cmap_test.go

@@ -2,7 +2,9 @@ package cmap
 
 import (
 	"fmt"
+	"runtime"
 	"strings"
+	"sync"
 	"testing"
 
 	"github.com/stretchr/testify/assert"
@@ -56,6 +58,61 @@ func TestContains(t *testing.T) {
 	assert.Nil(t, cmap.Get("key2"))
 }
 
+var sink any = nil
+
+func BenchmarkCMapConcurrentInsertsDeletesHas(b *testing.B) {
+	cm := NewCMap()
+	keys := make([]string, 100000)
+	for i := range keys {
+		keys[i] = fmt.Sprintf("key%d", i)
+	}
+	b.ResetTimer()
+
+	for i := 0; i < b.N; i++ {
+		var wg sync.WaitGroup
+		semaCh := make(chan bool)
+		nCPU := runtime.NumCPU()
+		for j := 0; j < nCPU; j++ {
+			wg.Add(1)
+			go func() {
+				defer wg.Done()
+
+				// Make sure that all the goroutines run at the
+				// exact same time for true concurrent tests.
+				<-semaCh
+
+				for i, key := range keys {
+					if (j+i)%2 == 0 {
+						cm.Has(key)
+					} else {
+						cm.Set(key, j)
+					}
+					_ = cm.Size()
+					if (i+1)%3 == 0 {
+						cm.Delete(key)
+					}
+
+					if (i+1)%327 == 0 {
+						cm.Clear()
+					}
+					_ = cm.Size()
+					_ = cm.Keys()
+				}
+				_ = cm.Values()
+			}()
+		}
+		close(semaCh)
+		wg.Wait()
+
+		sink = wg
+	}
+
+	if sink == nil {
+		b.Fatal("Benchmark did not run!")
+	}
+	sink = nil
+}
+
 func BenchmarkCMapHas(b *testing.B) {
 	m := NewCMap()
 	for i := 0; i < 1000; i++ {