Extract ByteSequence.

It isn't very object-y yet, but we're doing this in steps..
Tweak a name.
Add type suffix.
Extract ConstantType.
Time to class this joint up a notch.
Extract FloatingPointType.
Extract IntegerType.
Extract NamedType.

There is an inherent circularity here, which the absence of a linker
allows me to ignore.  It's marked with a TODO, and I'll return to it
before merging.
Extract PackedType.

Like NamedType, there is an ignored circularity here.
Remove the classes dir on clean.
Break #parse_simple_type into parts along ruby impl class boundaries.

This implies creating #parse_bool_type, which has not yet needed a
ruby impl.  I expect it may be merged in with packed_type before long.
Extract a (very simple) BooleanType.

The specs can't be moved from packed_type_spec yet, since they really
are testing PackedType: they (and the shared `type_examples`) need
`described_class` to be `PackedType`.
Forgot a boolean_type require.
Askari::Type#[] returns BaseTypes now, not java objects.

This is the heart of the refactoring.  From here we will be able to
hide the java implementations within ruby object constructors, perhaps
decompose the parsing process and drop `Type.encode_to_stream` and
`.decode_from_stream` in favor of polymorphic dispatch.
Push references to Java::AskariTypes down into ruby definitions.
Push parsing code down into ruby types.
We can fold the branches of these conditionals.
Ruby type objects receive #encode_to_stream and #decode_from_stream.

They are no longer passed as the initial parameter.
Move the boolean specs.
It seems we can dispense with the circularity.