rework ZIR memory layout; overhaul source locations

[andrewrk]

This is a follow-up from #7920, applying the same principles and strategies to ZIR.

The memory layout for ZIR instructions is completely reworked. See
zir.zig for those changes. Some new types:

• zir.Code: a "finished" set of ZIR instructions. Instead of allocating
  each instruction independently, there is now a Tag and 8 bytes of
  data available for all ZIR instructions. Small instructions fit
  within these 8 bytes; larger ones use 4 bytes for an index into
  extra. There is also string_bytes so that we can have 4 byte
  references to strings. zir.Inst.Tag describes how to interpret
  those 8 bytes of data.

  • This is shared by all Block scopes.

• Module.WipZirCode: represents an in-progress zir.Code. In this
  structure, the arrays are mutable, and get resized as we add/delete
  things. There is extra state to keep track of things. This struct is
  stored on the stack. Once it is finished, it produces an immutable
  zir.Code, which will remain on the heap for the duration of a
  function's existence.

  • This is shared by all GenZir scopes.

• Sema: represents in-progress semantic analysis of a zir.Code.
  This data is stored on the stack and is shared among all Block
  scopes. It is now the main "self" argument to everything in the file
  that was previously named zir_sema.zig.
  Additionally, I moved some logic that was in Module into here.

Module.Fn now stores its parameter names inside the zir.Code,
instead of inside ZIR instructions. When the TZIR memory layout
reworking time comes, codegen will be able to reference this data
directly instead of duplicating it.

astgen.zig is (so far) almost entirely untouched, but nearly all of it
will need to be reworked to adhere to this new memory layout structure.

I have no benchmarks to report yet, as I am still working through
compile errors and fixing various things that I broke in this branch.

Overhaul of Source Locations:

Previously we used usize everywhere to mean byte offset, but sometimes
also mean other stuff. This was error prone and also made us do
unnecessary work, and store unnecessary bytes in memory.

Now there are more types involved into source locations, and more ways
to describe a source location.

• AllErrors.Message: embrace the assumption that files always have less
  than 2 << 32 bytes.
• SrcLoc gets more complicated, to model more complicated source
  locations.
• Introduce LazySrcLoc, which can model interesting source locations
  with very little stored state. Useful for avoiding doing unnecessary
  work when no compile errors occur.

Also, previously, we had src: usize on every ZIR instruction. This is
no longer the case. Each instruction now determines whether it even cares
about source location, and if so, how that source location is stored.
This requires more careful work inside Sema, but it results in fewer
bytes stored on the heap, without compromising accuracy and power of
compile error messages.

Miscellaneous:

• std.zig: string literals have more helpful result values for
  reporting errors. There is now a lower level API and a higher level
  API.
  • side note: I noticed that the string literal logic needs some love.
    There is some unnecessarily hacky code there.
• cut & pasted some TZIR logic that was in zir.zig to ir.zig. This
  probably broke stuff and needs to get fixed.
• Removed type/Enum.zig, type/Union.zig, and type/Struct.zig. I don't
  think this quite how this code will be organized. Need some more
  careful planning about how to implement structs, unions, enums. They
  need to be independent Decls, just like a top level function.

[andrewrk]

Follow-up issues extracted:

• test coverage for all compile errors #8402
• test coverage for source locations & inlined function calls from different files #8403
• miscellaneous performance enhancement ideas extracted from the zir-memory-layout branch #8404