libexpr: Reduce the size of Value down to 16 bytes

This shaves off a very significand amount of memory used
for evaluation as well as reduces the GC-managed heap.

Previously the union discriminator (InternalType) was
stored as a separate field in the Value, which takes up
whole 8 bytes due to padding needed for member alignment.
This effectively wasted 7 whole bytes of memory. Instead
of doing that InternalType is instead packed into pointer
alignment niches. As it turns out, there's more than enough
unused bits there for the bit packing to be effective.

See the doxygen comment in the ValueStorage specialization
for more details.

This does not add any performance overhead, even though
we now consistently assert the InternalType in all getters.

This can also be made atomic with a double width compare-and-swap
instruction on x86_64 (CMPXCHG16B instruction) for parallel evaluation.

Author: xokdvium

src/libexpr/eval-gc.cc

@@ -4,6 +4,7 @@
 #include "nix/util/config-global.hh"
 #include "nix/util/serialise.hh"
 #include "nix/expr/eval-gc.hh"
+#include "nix/expr/value.hh"
 
 #include "expr-config-private.hh"
 
@@ -52,6 +53,13 @@ static inline void initGCReal()
 
     GC_INIT();
 
+    /* Register valid displacements in case we are using alignment niches
+       for storing the type information. This way tagged pointers are considered
+       to be valid, even when they are not aligned. */
+    if constexpr (detail::useBitPackedValueStorage<sizeof(void *)>)
+        for (std::size_t i = 1; i < sizeof(std::uintptr_t); ++i)
+            GC_register_displacement(i);
+
     GC_set_oom_fn(oomHandler);
 
     /* Set the initial heap size to something fairly big (25% of