By the spec, `arrPtr[i]` is a shortcut for `(*arrPtr)[i]`, where
`arrPtr` is a variable of an array pointer type, such as `*[1]int`.
Rewriting AST in this way concentrates all logic for pointer
dereferencing in one place, which should make future refactorings
simpler.

...and also document what "wrapped" types are about, because it took me
a looong time to figure out. Turns out this is pretty much a form of
primitive type boxing that is done in languages like Java.

Array-pointer types are one of the wrapped types, which means they are
represented by a native JS type at runtime, except for a few situations
when access to the full Go type needs to be preserved. To wrap such a
value, the native value is passed as a single constructor argument, but
named array pointer types did not provide that, using a default
constructor for all pointer types.

Array pointers are the only kind of pointer considered a "wrapped", so
they need to be handled appropriately. At runtime an array pointer is
represented by a reference to the JavaScript native array object, so we
only need to copy the reference and couple it with the desired Go type.
It will be boxed into the new Go type if/when the compiler needs it down
the road.

Upstream uses a conversion to unsafeheader.Slice, which isn't supported
by GopherJS. Using Value.Len() is preferrable, since we already override
it to provide compatibility. If/when
golang/go#48346 gets into the stable release,
this patch will no longer be necessary.