Remove unnecessary old entries from .gitignore
Don't allow clang to mark plinth_throw as nounwind
Add the 'create' keyword

This keyword is used to:
* Create compound types
* Declare constructors
* Declare property constructors

This change also removes the 'constructor' keyword, since it has been
completely replaced by 'create'.
Actually propagate types for property initialisers
Finally Add Generics!

Generics have been in progress for quite a while now. This commit adds
everything that should be needed to do generic types. The features added
by this commit are:
* The ability to add type parameters to classes, interfaces, and
  compound types.
* The ability to use type parameters as if they were normal types.
* The ability to use *any* type as a type argument.
  (i.e. not just objects: functions and primitives etc. work too)
* The ability to implement the same generic interface multiple times
  with different type arguments, and if there are methods which have
  type parameters in their signature, they can be overridden separately
  for each value of the type argument.
* The ability to check whether something is an instance of a type
  parameter (using run-time type information).
* Exceptions can now have generic type parameters.

The one feature removed by this commit is the ability to have native
upcalls on interfaces. This was made impossible to do nicely because of
the ability to have two different implementations of the same interface
in the same object.
Static native upcalls are still permitted everywhere.

The features which have not yet been added, but will in the future are:
* Wildcard types (parsing them already works, but using them causes a
  compile-time error).
* Method-level type parameters.

Adding generics required several major internal changes to the structure
of the compiler:
* The language grammar needed lots of changes to cope with having angle
  brackets in places where they could be mistaken for bit shifts or
  comparisons. An example of something difficult to parse:
  a<b,c<d,e>>(f)
  This could be a tuple of three expressions, or a creation of a
  compound type named "a". Because of this ambiguity, compound type
  creations now require a "create" keyword.
* Throughout the compiler, uses of Members have been replaced by
  references to members with the generic types filled in. For example,
  FunctionCallExpression now has a resolved MethodReference rather than
  a resolved Method.
* The run-time type information (RTTI) system has been improved
  drastically, so that type equivalence and 'instanceof' checks can be
  done easily.
* Virtual function table search lists now use RTTI rather than strings,
  which also facilitates the 'instanceof' operator with generic types.
* Function overriding now uses RTTI instead of strings for representing
  types, which allows it to be much more flexible as described above.
* The calling convention for interfaces has been revamped to avoid the
  expensive VFT lookup at the start of each interface function, at the
  cost of some binary compatibility constraints which generics would
  have broken anyway.
* A way of converting from one function type to another has been added,
  which uses proxy functions. This is required in order to perform
  implicit conversions such as from {T -> void} to {uint -> void}.
* The native type of arrays has been rethought. In order to cope with
  the implicit conversion from e.g. []{T -> void} to []{uint -> void},
  we need to create a proxy array which behaves just like a normal array
  but stores its values in a base array and converts the values being
  stored/retrieved.
* Exception types are no longer checked inside the personality function,
  instead they are checked at the landing pad. This was necessary in
  order to check for generic exceptions.

There are probably more changes than have been mentioned here, and
although I did a fair amount of testing, there may still be some bugs.