Fix Log::Metadata#dup crash with 2+ entries

[HertzDevil]

All reference types have a default #dup implementation that allocates new storage with size equal to instance_sizeof(self). Log::Metadata uses custom allocation and instances with 2 or more entries are larger than that size, but the default #dup only copies the first entry, so anything after that is uninitialized memory and can lead to crashes: (in this case :unchecked probably comes from the symbol's internal ID, used in Mutex)

puts Log::Metadata.new(nil, {a: 1, b: 2}).dup
# a: 1, unchecked: Program hit a breakpoint and no debugger was attached

Since Log::Metadata is immutable, #dup can be a no-op. A true shallow copy would have been:

def dup : self
  data_size = instance_sizeof(self) + sizeof(Entry) * {@size - 1, 0}.max
  copy = GC.malloc(data_size).as(self)
  copy.as(Void*).copy_from(self.as(Void*), data_size)
  copy
end

[Sija]

Shouldn't this use:

Suggested change

	Log::Metadata.empty.dup.should eq(Log::Metadata.empty)
	Log::Metadata.empty.dup.should be(Log::Metadata.empty)

[straight-shoota]

I think this would be testing .empty more than #dup... But yeah technically, all expectations could use be. But I think that's actually an implementation detail. It's not strictly necessary for #dup to return the same instance, but it does that for performance reasons.

[HertzDevil]

It isn't part of #dup's contract to preserve object identity of immutable reference types, one day #dup might create a shallow copy for other reasons. So eq suffices for unit tests of #dup