test: make assertMemoryLeak assert strict per-tag equality -- single-tag leaks passed

LeakCheck.close() absorbed any growth confined to a single memory tag
into a tolerated diff (mem + diff == memAfter holds when exactly one
tag grew), so a lone-tag native leak -- the common case -- passed the
check. The shape was ported from upstream QuestDB, where the tolerance
is scoped to NATIVE_SQL_COMPILER only; the per-tag filter was lost in
the port and this client has no such tag, so no exemption applies.

Proven vacuous empirically: disabling the M7 stub close under the old
check stayed green; under the strict check all 18 tests fail with
'native memory leaked or over-freed under tag NATIVE_DEFAULT
expected:<0> but was:<131328>' (exactly recv 64K + send 64K + control
256B per stub).

Tightening surfaced 63 latent failures across 6 classes -- all
root-caused and fixed in the two preceding commits (two production
ctor leaks, two test free-ordering bugs, one test cleanup gap); none
suppressed. MemoryTag.nameOf() added (mirrors upstream) so failures
name the offending tag.

Author: bluestreak01

core/src/main/java/io/questdb/client/std/MemoryTag.java

@@ -38,4 +38,31 @@ public final class MemoryTag {
     public static final int NATIVE_TLS_RSS = NATIVE_TEXT_PARSER_RSS + 1;
     public static final int NATIVE_ND_ARRAY = NATIVE_TLS_RSS + 1;
     public static final int SIZE = NATIVE_ND_ARRAY + 1;
+
+    public static String nameOf(int tag) {
+        switch (tag) {
+            case MMAP_DEFAULT:
+                return "MMAP_DEFAULT";
+            case NATIVE_PATH:
+                return "NATIVE_PATH";
+            case NATIVE_DEFAULT:
+                return "NATIVE_DEFAULT";
+            case NATIVE_DIRECT_UTF8_SINK:
+                return "NATIVE_DIRECT_UTF8_SINK";
+            case NATIVE_HTTP_CONN:
+                return "NATIVE_HTTP_CONN";
+            case NATIVE_ILP_RSS:
+                return "NATIVE_ILP_RSS";
+            case NATIVE_IO_DISPATCHER_RSS:
+                return "NATIVE_IO_DISPATCHER_RSS";
+            case NATIVE_TEXT_PARSER_RSS:
+                return "NATIVE_TEXT_PARSER_RSS";
+            case NATIVE_TLS_RSS:
+                return "NATIVE_TLS_RSS";
+            case NATIVE_ND_ARRAY:
+                return "NATIVE_ND_ARRAY";
+            default:
+                return "unknown[" + tag + "]";
+        }
+    }
 }

core/src/test/java/io/questdb/client/test/tools/TestUtils.java

@@ -266,20 +266,23 @@ public void close() {
                 return;
             }
 
-            // Checks that the same tag used for allocation and freeing native memory
+            // Every tag must return to its baseline. The previous shape
+            // (ported from upstream, which exempts NATIVE_SQL_COMPILER only)
+            // absorbed any growth confined to a single tag into a tolerated
+            // diff, so a lone-tag leak (e.g. NATIVE_DEFAULT) passed the check.
+            // This client has no SQL-compiler tag, so no exemption applies:
+            // assert strict per-tag equality, then total equality.
             long memAfter = Unsafe.getMemUsed();
-            long memNativeSqlCompilerDiff = 0;
             Assert.assertTrue(memAfter > -1);
-            if (mem != memAfter) {
-                for (int i = MemoryTag.MMAP_DEFAULT; i < MemoryTag.SIZE; i++) {
-                    long actualMemByTag = Unsafe.getMemUsedByTag(i);
-                    if (memoryUsageByTag[i] != actualMemByTag) {
-                        Assert.assertTrue(actualMemByTag >= memoryUsageByTag[i]);
-                        memNativeSqlCompilerDiff = actualMemByTag - memoryUsageByTag[i];
-                    }
+            for (int i = MemoryTag.MMAP_DEFAULT; i < MemoryTag.SIZE; i++) {
+                long actualMemByTag = Unsafe.getMemUsedByTag(i);
+                if (memoryUsageByTag[i] != actualMemByTag) {
+                    Assert.assertEquals(
+                            "native memory leaked or over-freed under tag " + MemoryTag.nameOf(i),
+                            memoryUsageByTag[i], actualMemByTag);
                 }
-                Assert.assertEquals(mem + memNativeSqlCompilerDiff, memAfter);
             }
+            Assert.assertEquals("total native memory", mem, memAfter);
         }
 
         public void skipChecks() {