Have some types.

Askari::Schema::V0::Types.[] takes a type 'name' (a bit of parsed
yaml) and returns a java pojo that serves as the type itself.

When the name is malformed, a syntax error is raised instead.  So,
Types.[] serves as a type validator.

The type objects do not yet do anything, but they exhibit a reasonable
class hierarchy to hang serialization logic on.
Flush out some pending type-related tests.

Also document (but do not enforce) how booleans are packed into bytes
for serialization.  One consequence is they must appear in herds of
whole bytes.  This is not yet enforced.
Update specs to reflect actual type naming.
Switch the braces between known types and constants.

Now a byte is `b1` instead of `[b1]`, but the constant foo is `[foo]`.

I find this improves brevity and readability.
Do some type validation at the java level.
Extract a package-private type base class.
isWholeByteSized indicates if an whole number of bytes are used.

This can be known even if the bit width is not.  We need it to
determine when boolean flags are packed into groups of 8.
Add isStreamDecodeable.

It determines if a value is decodeable from an infinite byte stream.

We need it as a building block of isDecodeable (to come), which will
dictate if a value of the type could be decoded from a finite octet
sequence.

That will be identical to isStreamDecodeable for all types except
PackedType; a packed type is still decodeable so long as all
components *except possibly the last* are stream decodeable.
isDecodeable dictates if a value can be decoded.

Specifically, if it can be decoded from a finite octet sequence of
known length, which is the only use case we actually care about.

The implementation is obvious, except for PackedType.  A packed type
is decodeable if all of its components are *and* if all its components
(save perhaps the last) are also stream decodeable.

The last component can get away with not being stream decodeable
simply by consuming the rest of the buffer.
Whoops.
Rename ByteTupleType@width -> @byteWidth.
Determine if types are (internally|) byte aligned.

Internal byte alignment applies only to types with subfields (so,
PackedType), and is vacuously true for all others (save NamedField,
which delegates.)

It is true precisely when all whole-byte-sized subfields of a value
begin on byte boundaries so long as the value itself does.

The idea is it should identify when a packed type has bit flags that
don't pack into a whole number of bytes.  We want to reject such types
immediately since they're a pain to en/decode.

Byte alignment is a refinement of internal byte alignment that further
requires that the type is whole-byte-sized.  Notice that a bool is
(vacuously) internally byte aligned but not byte aligned.

A packed type could be internally byte aligned but not byte aligned
(if it has stray booleans at the end, for example.)  We want to reject
these as well.
PackedType#isWholeByteSized now respects whole sized, variable types.
A type is well-formed iff it is decodeable and byte aligned.

Shortly it will also the only kind of type you can use in a schema.
Validation checks well-formedness of mentioned types.
doco
Start semantic validation of version_column.
The rest of version_column semantic validation.
Packs of named types (shallowly) forbid duplicate names.

Note, since packs can't be packed, the shallow flavor is all there is.