The use of AtomicU16 requires Rust 1.34 or newer, as it's only available
when using nightly Rust on older versions.

1.31 introduced Rust 2018, not 1.30.

This replaces the VM dependency on std::intrinsics with a dependency on
std::arch. The std::arch module provides the means to perform CPU
prefetching, but without having to use Rust nightly.

This means we can finally remove any traces of nightly-only features,
including those used for parking_lot (which weren't very useful to begin
with).

All of this means you can now build the VM on stable Rust, while still
being able to benefit from CPU prefetching.

This should make it a bit easier to install the compiler on systems with
slightly older versions of Ruby, such as Debian stretch.

This all in preparation for the upcoming Inko website.

Using "var" is a bit confusing because one might read it as "variable"
opposed to something along the lines of "mutable variable". Using "let
mut" makes it more clear that we're defining a mutable variable, it also
ensures both definitions always start with the same keyword.

The compiler now embraces prototype OO more, removing any mentions to
"classes", instead providing a simple "object" keyword. This keyword on
the outside behaves the same, but the underlying code/behaviour is much
more straightforward. For example, this:

    object Person {
      fn init(name: String) {
        let @name = name
      }
    }

Is (roughly) compiled down to this:

    let Person = Object.new

    fn(self) {
      fn new(name: String) {
        let instance = prototype.new

        instance.init(name)

        instance
      }

      fn init(name: String) {
        let @name = name
      }
    }.call(Person)

Here "Object.new" creates an empty object with its prototype set to
"Object". In this setup there are no class methods, but I actually quite
like this. Since you can define methods directly in a module there isn't
really a good reason to support class methods.

One big benefit of this approach is that bootstrapping is much simpler,
and the compiler can more easily infer types. I personally also find it
much easier to reason about objects when you have _just_ objects and
methods, instead of also having classes and meta classes.

With this also comes the decision to expose prototypes more to the
language. For example, Object will respond to the "prototype" message
instead of responding to some kind of "class" message.

Finally, in this commit the compiler is also changed to mostly rely on
message sending for defining core constructs. For example, when you
define a trait like so:

    trait ToString {
      fn to_string -> String
    }

It's (roughly) compiled down to:

    let ToString = Trait.new

    fn(self) {
      define_required_method('to_string')
    }.call(ToString)

Knowledge such as the type signatures of the required methods or any
type arguments will only be known to the compiler for the time being.

The old prototype compiler written in Ruby is being replaced with a Rust
based compiler.

Inko ("インコ") means parrot/parakeet in Japanese. In Inko communication
happens via message passing, for both objects and processes. Naming the
language after parrots/parakeets (a rather vocal type of bird, some
known for mimicking human speech) makes more sense than naming it after
the concept of eternity. Furthermore, naming the language after parrots
allows the creation of a proper logo and mascot; something quite hard
when your language is called "Aeon".