I wanted to make CVM's forth use the Grid subsystem, but doing so
would break the stage binary. Hence, this split.

I always keep it on myself. I can imagine it's especially useful to
newcomers.

I'm not sure why I chose null-terminated initially. Probably because
the z80asm version had null-terminated strings.

Length-prefixes strings are the traditional form of strings in Forth
and it's a bit easier to work with them with traditional forth words
when they're under this form.

Read the contents of forth.bin at runtime. This allows us to get
rid of the bin2c tooling.

Instead, embed absolute path to blkfs. Having to rebuild the stage
binary at every change in blkfs is getting tedious.

During "make updatebootstrap", we use less than 0x20 bytes on the
PSP side and less than 0x40 bytes on the RSP one. 0x100 bytes ought
to be enough for anybody.

XPACKed source needing to be kept in bootstrap bin didn't make
much sense. With the removal of stripfc, it makes more sense to keep
the compiled form of stage 1 in repository as a bootstrap binary.

Also, rename it to forth.bin.

Big bootstrapping change which greatly reduces the role of the modern
operating system in the bootstrapping process.

More reliable.

Less noisy this way

This allows us to remove forth/z80a.fs. Another big step towards
self-hosting!

To update LATEST offset more easily. Will be useful for recipes.

Make LATEST configurable through a value in the binary instead of through
a ZASM constant. This enables the simple concatenation of compiled dicts and
simplifies the build process.

Now we're having a real nice and tidy forth.asm...

They do save space (nearly 100b), but they complicate our Forth-ification
process. We'll re-add them later.

This allows us to save a whole 500 bytes on the final binary size!

This change comes after I took a look at the hex dump and saw that one letter
constants in z80a.fs took a lot of space.

This requires us to significantly adjust our build process, which
now has 3 stages.

The goal being to add a new native code dict staging phase.

This should help with upcoming challenges in bootstrapping z80 code
compiled through Forth.

My approach with RS was slightly wrong: RS' TOP was always containing current
IP. It worked, but it was problematic when came the time to introduce
RS-modifying words: it's impossible to modify RS in a word without immediately
messing your flow.

Therefore, what used to be RS' TOS has to be a variable that isn't changed
midway by RS-modifying words. I guess that's why RS is called *return* stack...

Big one.

This allows us to write higher order words directly in Forth, which is much
more convenient than writing post-immediate (see "NOT" structure in diff if
you want to see what I mean) structures in ASM.

These structures can then be written to ROM (rather than loaded in RAM for
definitions loaded at run-time).

That's quite a bit of tooling that was added, 2 compilations stages, but I
think it's well worth it.