Give the SHOW_MEMORY instrumentation a single definition per function

The coverage job compiles ConflictSet.cpp twice: once without SHOW_MEMORY,
like the rest of the build, and once with it for the SHOW_MEMORY test. Each
config previously saw a *different* definition of the accounting helpers:
no-op `constexpr` stubs near the top of the file when SHOW_MEMORY was off,
and the real definitions at the bottom when it was on.

gcovr reads the .gcda files for a source file and merges them, and its
default (strict) function merge mode asserts that a function name always
maps to one line. Since `addNode`, `removeNode`, `addKey`, both `removeKey`
overloads and `getSearchPathLength` were reported on two different lines,
report generation aborted with

    AssertionError: Got function getSearchPathLength(Node*) on multiple
    lines: 99, 6002.

Define those functions in exactly one place instead, and compile the
accounting out from within the bodies. Then every configuration reports each
function on the same line and the coverage data can be merged. The empty
calls are inlined away: the Release shared library contains no calls to
them.

With the merge fixed, the accounting lines that only exist in the SHOW_MEMORY
build show up in the report, so the coverage job's 100% line requirement
covers them. Extend the SHOW_MEMORY test to grow a node through every node
type (so `getNodeSize` covers every case) and to erase entries one at a time
via `setOldestVersion` (so `removeKey` and the `internal_setOldestVersion`
cross-check are covered). The remaining `abort()`s in the accounting are
defensive checks that can never be taken on a passing run; mark them
GCOVR_EXCL_LINE like the rest of the unreachable code in this file.

ShowMemoryTest.cpp

@@ -86,4 +86,30 @@ int main() {
     assert(checkPoint(cs, "other/999", version) == ConflictSet::Conflict);
   }
   checkFullyReleased();
+
+  // Grow a node through every node type, so that the accounting for each node
+  // type's size is exercised, then erase the entries one at a time so that
+  // nodes are released individually rather than as part of a whole tree.
+  {
+    ConflictSet cs{0};
+    std::string key(1, '\0');
+    for (int i = 0; i < 256; ++i) {
+      key[0] = char(i);
+      writePoint(cs, key, i + 1);
+    }
+    for (int i = 0; i < 256; ++i) {
+      key[0] = char(i);
+      assert(checkPoint(cs, key, i) == ConflictSet::Conflict);
+    }
+
+    // Garbage collection erases entries that can only fail with TooOld anyway.
+    // Doing it one version at a time walks the tree, erasing, downsizing and
+    // releasing nodes as it goes.
+    for (int i = 0; i < 256; ++i) {
+      cs.setOldestVersion(i + 1);
+    }
+    key[0] = '\0';
+    assert(checkPoint(cs, key, 0) == ConflictSet::TooOld);
+  }
+  checkFullyReleased();
 }