Honestly, I don't even know if this is the direction to go, but considering that the term "byte-packed" and "bit-packed" have already been used before, it makes sense to me to use `bitpack` to refer to the bitpack structs and unions while using "bit-packed" when saying that something is bitpacked.
`analyzeLoad` can now always assume that it's being called on a single-item
pointer.
`pointerDeref` is now split into `maybeDerefPtr` and `derefPtr`, both of
which assume that the pointer they're loading is already coerced to the
correct type. Call sites have been adjusted to now actually do that.
`maybeDerefSliceAsArray` and `derefSliceAsArray` now only work with slices
and not also with single pointers to arrays, call sites that previously
relied on that behavior now use `maybeDerefPtr` or `derefPtr` directly.
`fieldCallBind` doesn't have to check for a c pointer anymore because
ZIR `ref`/`ref_const` rl always yields a single-item pointer.
Similarly `fieldPtr` can now assume that its operand is a single-item
pointer for the same reason.
Renamed and moved some functions so that related things are next to each other.
Basically removes a bunch of special casing for slices from the main `analyzeLoad`
code path and moves it to the new `preparePtrForDeref` function which supplants
the `verifyDeref` function. The `preparePtrForDeref` function turns slices with
comptime-known lengths into single-item pointers to arrays and is called directly
in the functions where that kind of conversion could happen. All subsequent code
now doesn't have to deal with the possibility that a derefable pointer could be a
slice anymore.
This fixes a bug where dereferencing a slice of an OPV type would result in
a single instance of that OPV type as if the slice had been a single-item
pointer to that type.