stage2: type system treats fn ptr and body separately

[andrewrk]

This commit updates stage2 to enforce the property that the syntax
fn()void is a function body not a pointer. To get a pointer, the
syntax *const fn()void is required.

ZIR puts function alignment into the func instruction rather than the
decl because this way it makes it into function types. LLVM backend
respects function alignments.

Struct and Union have methods fieldSrcLoc to help look up source
locations of their fields. These trigger full loading, tokenization, and
parsing of source files, so should only be called once it is confirmed
that an error message needs to be printed.

There are some nice new error hints for explaining why a type is
required to be comptime, particularly for structs that contain function
body types.

Type.requiresComptime is now moved into Sema because it can fail and
might need to trigger field type resolution. Comptime pointer loading
takes into account types that do not have a well-defined memory layout
and does not try to compute a byte offset for them.

fn()void syntax no longer secretly makes a pointer. You get a function
body type, which requires comptime. However a pointer to a function body
can be runtime known (obviously).

Compile errors that report "expected pointer, found ..." are factored
out into convenience functions checkPtrOperand and checkPtrType and
have a note about function pointers.

Implemented Value.hash for functions, enum literals, and undefined values.

stage1 is not updated to this (yet?), so some workarounds and disabled
tests are needed to keep everything working. Should we update stage1 to
these new type semantics? Yes probably because I don't want to add too
much conditional compilation logic in the std lib for the different
backends.

I think this code is mostly working, I just need to figure out why a field_call_bind instruction is returning the wrong type for the function pointer.