Implement bump pointer allocator for allocTmp()

Replace individual calloc() calls with efficient block-based allocation:
- Allocate from larger blocks (4KB initial, grows to 64KB max)
- O(1) pointer bump for allocations within block
- 8-byte alignment for structure safety
- Blocks freed per-frame in flushAllocTmp()

Benefits:
- Fewer malloc calls: 1-2 blocks vs 20-30 individual allocations/frame
- Better cache locality with contiguous allocations
- Simpler cleanup: free 1-2 blocks instead of looping 20-30 times

Author: tmikov

lib/imgui-unit/asciiz.js

@@ -118,18 +118,58 @@ function tmpAsciiz(s: any): c_ptr {
 }
 
 
-let _allocas: c_ptr[] = [];
+// Bump pointer allocator for temporary allocations
+const INITIAL_BLOCK_SIZE = 4096;
+const MAX_BLOCK_SIZE = 65536;
+const ALIGNMENT = 8;
+
+let _blocks: c_ptr[] = [];
+let _currentBlock: c_ptr = c_null;
+let _currentOffset: number = 0;
+let _currentSize: number = 0;
+let _nextBlockSize: number = INITIAL_BLOCK_SIZE;
 
 function allocTmp(size: number): c_ptr {
-    let res = calloc(size);
-    _allocas.push(res);
-    return res;
+    // Round up to alignment boundary
+    size = (size + ALIGNMENT - 1) & ~(ALIGNMENT - 1);
+
+    // Check if allocation fits in current block
+    if (_currentOffset + size <= _currentSize) {
+        let ptr = _sh_ptr_add(_currentBlock, _currentOffset);
+        _currentOffset += size;
+        return ptr;
+    }
+
+    // Need a new block
+    let blockSize = _nextBlockSize;
+    // Large allocation - allocate exact size but don't grow block size
+    if (size > blockSize)
+        blockSize = size;
+
+    let newBlock = calloc(blockSize);
+    _blocks.push(newBlock);
+    _currentBlock = newBlock;
+    _currentSize = blockSize;
+    _currentOffset = size;
+
+    // Grow next block size
+    if (_nextBlockSize < MAX_BLOCK_SIZE)
+        _nextBlockSize = _nextBlockSize * 2;
+
+    return newBlock;
 }
 
 function flushAllocTmp(): void {
-    for (let i = 0; i < _allocas.length; ++i) {
-        _free(_allocas[i]);
+    // Free all blocks
+    for (let i = 0; i < _blocks.length; ++i) {
+        _free(_blocks[i]);
     }
+
+    // Reset all state
     let empty: c_ptr[] = [];
-    _allocas = empty;
-}
+    _blocks = empty;
+    _currentBlock = c_null;
+    _currentOffset = 0;
+    _currentSize = 0;
+    _nextBlockSize = INITIAL_BLOCK_SIZE;
+}