fix(adapters): standardize make/cleanup naming; reflect T in moodycamel name

Per Gemini review on PR #23.

1. nim_channel_adapter: rename initNimChannelAdapter → makeNimChannelAdapter
   and deinitNimChannelAdapter → cleanup, matching the
   makeLoonyAdapter / makeBoostLockfreeQueueAdapter / makeMoodycamelAdapter
   / makeCrossbeamArrayQueueAdapter convention.

2. threading_channels_adapter: same rename — initThreadingChannelsAdapter
   → makeThreadingChannelsAdapter, deinitThreadingChannelsAdapter →
   cleanup. Update the docstring's example accordingly.

3. moodycamel_adapter.name: drop the hardcoded `uint64` literal in the
   returned string and use $T. The C++ wrapper is uint64-specialized
   today, but the adapter is generic; keeping the name in sync with T
   matches every other adapter's name proc.

4. Update three call-site groups: bench_mpmc.nim's initThreadingChannelsQ
   wrapper, bench_mpsc.nim's initNimChannelQ wrapper,
   smoke_threading_channels.nim, and t_bench_adapters.nim suite blocks.

Compile-checked bench_mpsc and bench_mpmc locally.

Author: elijahr

benchmarks/nim/adapters/moodycamel_adapter.nim

@@ -86,4 +86,4 @@ when defined(adapter_moodycamel_available):
       PopResult[T](success: false)
 
   proc name*[T](a: MoodycamelAdapter[T]): string =
-    "moodycamel/ConcurrentQueue[uint64]"
+    "moodycamel/ConcurrentQueue[" & $T & "]"

benchmarks/nim/adapters/nim_channel_adapter.nim

@@ -53,7 +53,7 @@ when defined(adapter_nim_channel_available):
         ## stdlib's pre-ARC channel implementation does not
         ## support cleanly).
 
-  proc initNimChannelAdapter*[T](capacity: int = 1024
+  proc makeNimChannelAdapter*[T](capacity: int = 1024
   ): NimChannelAdapter[T] =
     ## ``capacity`` is the maximum number of in-flight messages.
     ## ``capacity <= 0`` selects an unlimited channel (matches
@@ -62,7 +62,7 @@ when defined(adapter_nim_channel_available):
     result.chan = create(Channel[T])
     result.chan[].open(if capacity < 0: 0 else: capacity)
 
-  proc deinitNimChannelAdapter*[T](a: var NimChannelAdapter[T]) =
+  proc cleanup*[T](a: var NimChannelAdapter[T]) =
     if a.chan != nil:
       a.chan[].close()
       dealloc(a.chan)

benchmarks/nim/adapters/threading_channels_adapter.nim

@@ -45,7 +45,7 @@ when defined(adapter_threading_channels_available):
       ## module reclaims the underlying buffer; we never call it
       ## directly.
 
-  proc initThreadingChannelsAdapter*[T](capacity: int = 1024
+  proc makeThreadingChannelsAdapter*[T](capacity: int = 1024
   ): ThreadingChannelsAdapter[T] =
     ## ``capacity`` maps to ``newChan[T]``'s ``elements`` argument.
     ## Defaulted to 1024 for parity with other bounded MPMC adapters.
@@ -54,12 +54,11 @@ when defined(adapter_threading_channels_available):
     let cap = if capacity <= 0: 1 else: capacity
     result.chan = newChan[T](elements = cap)
 
-  proc deinitThreadingChannelsAdapter*[T](
-      a: var ThreadingChannelsAdapter[T]) =
+  proc cleanup*[T](a: var ThreadingChannelsAdapter[T]) =
     ## Explicit teardown is a no-op: ``Chan[T]`` cleans itself up
     ## via its move/destroy hooks. The proc exists so callers can
-    ## use ``defer: deinitThreadingChannelsAdapter(a)`` for parity
-    ## with other adapters' ``cleanup`` shapes.
+    ## use ``defer: cleanup(a)`` for parity with other adapters'
+    ## ``cleanup`` shapes.
     discard a
 
   proc push*[T](a: var ThreadingChannelsAdapter[T], item: T): PushResult =

benchmarks/nim/bench_mpmc.nim

@@ -296,7 +296,7 @@ when defined(adapter_crossbeam_array_queue_available):
 
 when defined(adapter_threading_channels_available):
   proc initThreadingChannelsQ(capacity: int): ThreadingChannelsAdapter[uint64] =
-    initThreadingChannelsAdapter[uint64](capacity)
+    makeThreadingChannelsAdapter[uint64](capacity)
 
 proc runMvpMpmcShape[A](
     em: var BMFEmitter,

benchmarks/nim/bench_mpsc.nim

@@ -155,7 +155,7 @@ proc runMupsicShape[N, P: static int; T](
 
 when defined(adapter_nim_channel_available):
   proc initNimChannelQ(capacity: int): NimChannelAdapter[uint64] =
-    initNimChannelAdapter[uint64](capacity)
+    makeNimChannelAdapter[uint64](capacity)
 
   proc runNimChannelShape(
       em: var BMFEmitter,

benchmarks/nim/smoke/smoke_threading_channels.nim

@@ -23,8 +23,8 @@ proc main() =
   echo "threading_channels smoke: starting"
 
   block:
-    var a = initThreadingChannelsAdapter[uint64](capacity = 64)
-    defer: deinitThreadingChannelsAdapter(a)
+    var a = makeThreadingChannelsAdapter[uint64](capacity = 64)
+    defer: cleanup(a)
     for i in 0'u64 ..< 32'u64:
       let r = a.push(i)
       doAssert r == prSuccess, "threading_channels push failed at i=" & $i

tests/t_bench_adapters.nim

@@ -123,8 +123,8 @@ when defined(adapter_threading_channels_available):
   suite "threading_channels_adapter":
     test "push/pop 1000 uint64 round-trip preserves set":
       runRoundTrip[ThreadingChannelsAdapter[uint64]](
-        initThreadingChannelsAdapter[uint64](capacity = 4096),
-        deinitThreadingChannelsAdapter(adapter)
+        makeThreadingChannelsAdapter[uint64](capacity = 4096),
+        cleanup(adapter)
       )
 
 when defined(adapter_nim_channel_available):
@@ -134,6 +134,6 @@ when defined(adapter_nim_channel_available):
   suite "nim_channel_adapter":
     test "push/pop 1000 uint64 round-trip preserves set":
       runRoundTrip[NimChannelAdapter[uint64]](
-        initNimChannelAdapter[uint64](capacity = 4096),
-        deinitNimChannelAdapter(adapter)
+        makeNimChannelAdapter[uint64](capacity = 4096),
+        cleanup(adapter)
       )