It will make tokenization cleaner and it also makes the instruction
table significantly more compact.

instr.asm is for single instruction assembly.

* Build emulated zasm statically
* Improve comments in zasm.asm
* Fix build
* Use unsetZ from core

Also, clarify the role of recipes.

Very coarse, but I got them to work.

This way, we can interact with the mounted FS even when we change the
selected blkdev.

This will facilitate "copying" blk selection in FS.

This allows more than one file to be allocated. `fls` properly lists
multiple files.

Very incomplete, but if you play your cards right, you can, with the
shell:

1. Create a new CFS
2. Mount it
3. Allocate a file with an arbitrary name
4. Have it listed with `fls`

It wasn't a good idea to complicate all blockdev impls with complicated
seeks. Let's just stay in absolute mode for now.

Also, extract commands into blockdev_cmds to avoid making blockdev
dependent on stdio.

Allows seeking forward, backwards, to the beginning, to the end.

No consumer yet, but it's coming...

Calling on blkGetC repeatedly was somehow very unstable and often
failed. I didn't pinpoint exactly why, but keeping the call addr around
and calling that instead seems like a better idea anyway.

The opposite of "load"

Instead of waiting, GetC always return immediately, with Z indicating if
something was fetched. The "wait" loop is implemented by the called (and
in the new `blkGetCW`).

This simplifies out-of-bounds verifications for storage blockdevs.

Let's not create complex rules for exception cases.

A python script generates all possibilities for all supported
instructions and compare zasm output with scas. After having fixed a
couple of bugs, all tests pass!

This facilitates debugging. To know the value of `A` at any point,
you can do `out (0), a`. The number of bytes in the output will be the
value of `A`.

Looping is easier

Previously, we would go the other way around: match all available
argspecs to raw argument strings. It's much better to go the other way
around because we can "reduce" each argument much sooner. That will be
important when we start to support constants and expressions.