Add dependencies.
Port current version to standalone repo.
Rename "world" type to "float".

It makes less sense outside of Yugen and is fairly nonstandard.
Update README to show example hello world program with interop.
Support talking about user types in Yang code.

Modify grammar to allow identifiers in types, and in general remove the
distinction between expressions and types.. Resolvess a bunch of issues with
the parser.

Support the changes in static checker and IrGen. Add wrapper "named
expression" nodes around function arguments to make things work.
Add support for member functions on user-types.

On the way, made various improvements. In particular, moved Context to its
own file and used it directly as the interface for StaticChecker and
IrGenerator.

Closures would make a lot of this much simpler.
Clean up several things:

- Fixed a bug where symbol/metadata tables weren't always popped at the
  right time during static checking.
- Only allow identifiers on the right hand side of a member selection;
  allowing arbitrary expressions does not make the parsing any more
  flexible (since . is already this highest-precedence operator), and
  this removes a bunch of complexity.
- Conversely, allow arbitrary expressions on the left-hand side of an
  assignment. This does make parsing much more flexible, and may be
  useful in the future for unpacking assignment, etc.
Expand on directions for closures/interfaces.
Allow direct access to member functions via :: operator.

This means we don't need to treat function member separately and we can
delete a bunch of stuff.
As planned, functions are now represented by three pointers.

Currently, only the first is ever used. The other two will be useful in
implementing a bunch of nice features.
C++ functions are now called via generic trampolines using second pointer.

This involves a bunch of stuff:
- Logic to pass the target function (second pointer) when it's non-null.
- Uniquing of generic reverse trampolines.
- Static initialisation tricks to ensure C++ reverse trampolines are
  instatiated at compile-time if they might be needed, and are available
  during Yang compilation.

Still doesn't actually allow anything we couldn't do before; but it'll be
trivial to allow passing arbitrary C++ functions to Yang code now.
Rewrite a lot of the template trampoline generation.

The code is much cleaner, and it avoids calling functions through O(n)
lambda-closure/std::function wrappers for a target with n arguments.