Slice, channel and map types' constructors now have a .make() method
that implements the builtin for the corresponding type. The compiler
simply calls the builtin without a need to introspect the type.

Similar to make(), each relevant type constructor has a $len() method
that takes an unwrapped type value and returns its length. Whenever
len() is called with a type param, the compiler emits a call to
`Type.$len(value)`.

Unlike make(), I kept compile-time specializations of len(), since they
are much more likely to be called in performance-critical path and would
be cheaper than a call to `T.$len()`.

%f instructs the format to "flatten" all numeric types into a JS number.
To do that correctly, you need to know whether the passed number is
64-bit or less. In case of the type parameter we pass the type
constructor as a second argument to determine that at runtime.

Similar to len(), to maintain performance when used in loops I've kept
compile-time specializations for when the exact type is known.
Otherwise, a type-specific implementation is called at runtime.

For the most part it already worked through the $newDataPointer(), I
only had to update it to handle pointers to array, which are a wrapped
type.

Instead of interrogating the type of the slice or map expression passed
to the built-in, we interrogate types of the computed built-in
signature. In case of append(), it will be a slice of element types due
to variadic nature of the built-in. For map it will be the plain key
type. We can then use that type to translate expressing with implicit
conversion.