Support std.WasmPageAllocator

[fengb]

Now that we have a built-in page-based allocator in std, we should start consuming it.

Benefits:

• standardize around std — properly coordinate with any wasm allocator
• really freeing memory — this should be identical to ArenaAllocator.deinit
• potentially ignore jumbo allocations entirely

Drawbacks:

• the std allocator requires an additional 1-2 KB
• need new metadata architecture for C-like malloc()

Questions:

1. Is it possible to detect using "free()"? In theory, wasm_page_allocator can be tiny if it optimizes away the free/reuse bookkeeping, so it'd be amazing if it could detect at comptime whether free is needed.
2. Should we keep around the current dumb page allocator and only enable the new path on "deinit()"? std.WasmPageAllocator was designed to handle freeing any memory page (including ones it didn't originally allocate) so this works around question 1.

[fengb]

Brain dump of metadata for C-malloc:

Each page pointer (ptr % 65536) translates to an index. This should match the page index stored internally by std.WasmPageAllocator.

const Allocation = enum(u2) {
    None,
    Start,
    Continue,
};

const MallocCompatibility = struct {
    page_meta: PackedIntArray(),

    fn pageCount(self: Self, page_idx: usize) usize {
        assert(self.get(page_idx) == .Start);
        var count = 1;
        while (page_idx + count < self.size and self.get(page_idx + count) == .Continue) {
            count += 1;
        }
    }

    pub fn free(self: Self, ptr: [*]u8) void {
        if (ptr % 65536 == 0) {
            const count = self.pageCount(ptr / 65536);
            if (self.count > 1) {
                const slice = ptr[0 .. self.count * 65536];
                return allocator.free(slice);
            }
        }
        const slice = self.restore(ptr);
        return allocator.free(slice);
    }
};