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.

Our validator isn't aware of line numbers, but we note one way to get
them, if we want it.  It would be non-trivial.

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.

isStreamDecodeable determines if a value is decodeable from an
infinite byte stream. We need it as a building block of isDecodeable.

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.

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.

A type is well-formed iff it is decodeable and byte aligned.

We add a CLI to validate application schemas.  We do it in thor, and
waggle the java search paths to actually be correct (entries need to
be on $CLASSPATH, putting them on $: is useless.)