Compilation error fix for strict compiler flags
Allow memory-aligned closure component classes

The root of the issue which this change is addressed to solve is related
on fact that sometimes external defined closure classes might want to be
aligned to some boundary in memory in order to utilize SIMD instructions.

Adding alignment attributes to such classes might give compiler some tips
about possible optimization (which are hidden to developer). And the issue
is that compiler thinks such classes are being allocated using genuine C++
allocation, which takes care of alignment. This case is being violated by
the ClosureRegistry which allocates closures in a pool.

With such way of class allocation it's nearly impossible to use SIMD in
the closure classes, because there's no way to make sure data is properly
aligned in memory.

One of the possible solutions is to not use SIMD in the closures, but
this becomes a real PITA to glue the SIMD logic of the rest of the render
engine with non-SIMD-aware storage of the closure itself.

Better solution is to make memory pool aware of memory alignment requests
and allow external engines to declare if the closure needs to be aligned
in the memory.

This commit tries to implement this logic, and it's more or less straight
forward.

To be mentioned, the SimplePool now allows non-aligned size to be allocated
in the pool. It seemed quite an artificial limitation which i'm not sure why
it'll give issues.

System aligned malloc functions doesn't have such limitation and this gives
some flexibility IMO.
credits
Optiization: Be less conservative in implementation of unread_after().

It was really implemented as if it were "unread AT OR after". It's used
to determine whether it's safe to elide assignments to variables that
aren't subsequently use. But sometimes the assignment is a function
where the variable assigned to is also one of the arguments. For
example,
    x = func(x,y)
x is read on that op, but not AFTER. But because of how the unread_after
also discounted elision if used on that op, it was less aggressive than it
could have been in eliminating statements like this.