Allow access to type implementation as Type.impl.

This returns an implementation only if the type is a concrete type, rather
than a variable or a conflicted type.
TypeImplementation display_name is field, not property.
Base type for operation implementations.

Each TypeImplementation instance will have a selection of instances of
subclasses of this, each providing the implementation for one operation.
These will be used by the preprocessor and code generation phases.
An exception for signaling unsupported operations.
Integer implementations use display name attribute.

The interface changed so that display name is a plain attribute rather
than a property.
Beginnings of add and sub operations on integers.
Show only start position when stringifying symbols.

Entire source ranges have a pretty long repr(), making debug output very
noisy. This makes it a little more readable.
Warn if the preprocessor seems to be failing to converge.

This warning will likely go away as confidence increases, but right now
it's easy to introduce a bug that causes it to never converge, and it's
handy to get a warning about that, even if the way it's implemented is
pretty silly.
Use TypeInferer.get_inferences_for_block from infer.

Might as well use this accessor since we have it. That way it can grow
to do something special in future if need be.
Correct implementation of TypeTable equality.

Since type variables are different each time we run, we need to be careful
to compare these as equal regardless of their identity. When we talk about
changes to the type inference we really mean changes to what we know, not
changes to what we *don't* know.

This allows type inference to converge, where previously it was
impossible.
__repr__ for TypeTable.

Handy for debugging.
Type unification implementation.

Unifies two types into one, preferring concrete ones over variables.
Produces a conflicted type if presented with two concrete types, or with
a type that is already in conflict.

No tests yet, because time has run short today. Tests to follow later.
Name the UnknownSizeInteger type.

Previously it had no name because it wasn't expected to be user-facing,
but at least for the moment giving it a name is useful for debugging since
it gives something more sensible in error messages.
Type links in error messages.

All types mentioned in an error message get named together so that the
type variables are consistent between all of them.
Allow Unknown to be used inside intermediate.

Need to declare it above the imports in intermediate so that the
submodules of intermediate can use it.
QuickObject utility class.

This class allows the quick creation of ad-hoc objects with arbitrary
attributes. This is handy for implementing ad-hoc interfaces. Uses of this
should later be replaced with concrete classes, once the requirements are
clearer.
Basic get_result_type for BinaryOperation.
Skeleton boolean type.
is_less_than implementation for UnknownSizeInteger.
JumpInstruction.build_llvm_terminator implementations.

This will be used during code generation to produce basic block
terminators.