fix(container_allocator): Fix MSVC error by correcting allocator semantics

ROOT CAUSE:
The allocate() function was incorrectly constructing objects during memory
allocation, violating C++ allocator requirements. MSVC's std::_Tree_node has
a deleted default constructor, causing compilation failure.

CHANGES:
1. container_allocator::allocate() - Now only allocates raw memory without
   constructing objects (removed mem::$new and ipc::construct calls)
2. container_allocator::deallocate() - Now only frees memory without
   destroying objects (removed mem::$delete and ipc::destroy_n calls)

WHY THIS FIXES THE ISSUE:
- C++ allocator semantics require strict separation:
  * allocate()   -> raw memory allocation
  * construct()  -> object construction
  * destroy()    -> object destruction
  * deallocate() -> memory deallocation

- std::map and other containers call construct() with proper arguments
  (key, value) to initialize nodes, not allocate()

- std::_Tree_node in MSVC has no default constructor (= delete), so
  attempting to construct it without arguments always fails

- The previous code tried to default-construct objects in allocate(),
  which is both semantically wrong and impossible for _Tree_node

PREVIOUS FIX (uninitialized.h):
The earlier fix to uninitialized.h was insufficient - even with correct
T() vs T{} handling, you cannot default-construct a type with deleted
default constructor.

Fixes MSVC 2017 compilation error:
error C2280: attempting to reference a deleted function

Author: mutouyun

include/libipc/mem/container_allocator.h

@@ -63,26 +63,18 @@ class container_allocator {
   pointer allocate(size_type count) noexcept {
     if (count == 0) return nullptr;
     if (count > this->max_size()) return nullptr;
-    if (count == 1) {
-      return mem::$new<value_type>();
-    } else {
-      void *p = mem::alloc(sizeof(value_type) * count);
-      if (p == nullptr) return nullptr;
-      for (std::size_t i = 0; i < count; ++i) {
-        std::ignore = ipc::construct<value_type>(static_cast<byte *>(p) + sizeof(value_type) * i);
-      }
-      return static_cast<pointer>(p);
-    }
+    // Allocate raw memory without constructing objects
+    // Construction should be done by construct() member function
+    void *p = mem::alloc(sizeof(value_type) * count);
+    return static_cast<pointer>(p);
   }
 
   void deallocate(pointer p, size_type count) noexcept {
     if (count == 0) return;
     if (count > this->max_size()) return;
-    if (count == 1) {
-      mem::$delete(p);
-    } else {
-      mem::free(ipc::destroy_n(p, count), sizeof(value_type) * count);
-    }
+    // Deallocate raw memory without destroying objects
+    // Destruction should be done by destroy() member function before deallocate
+    mem::free(p, sizeof(value_type) * count);
   }
 
   template <typename... P>