Using Windows containers in Docker has been a painful experience. Slow
networks, no support for transparent networks due to the host being a
VPS, building large containers taking forever, the list goes on.
Meanwhile it costs me roughly €50 per month to keep the Windows CI
runner online.

Since we already have a Mac Mini at MacStadium (for free), we can just
re-use that Mac and run Windows inside a VirtualBox VM. This allows us
to work around the various Docker issues on Windows, and should reduce
our monthly infrastructure costs to more or less €0 (excluding the €1-2
I pay to AWS every month).

As part of this we also re-organise the runner tags a bit: the runners
now use three tags:

1. "inko"
2. "vbox" (to indicate it's a virtualbox runner)
3. "macos" or "windows", based on the type of OS

This ensures we don't accidentally pick up a shared runner that just
uses a "windows" or "macos" tag.

Version 0.2.x of the "time" crate comes with an API that is quite
different from version 0.1.x. This commit upgrades Inko to this new AP.
As version 0.2.x does not support checking if DST is active, support for
this has been removed. DST support is tricky, as it can vary based on
where you are, politics (e.g. some countries may drop it), etc.

As part of upgrading to time 0.2.x, some of the internals for obtaining
timestamps has been changed. In particular, obtaining a timestamp and
UTC offset has been merged into a single VM instruction. This should
ensure that no funny business happens when obtaining a timestamp but not
obtaining the UTC offset until a later point in time. The downside is
having to allocate an array object, but the overhead of this should be
minor.

This fixes #188

When implementing a trait for an object or when re-opening an object,
the compiler required that you specify the type parameter names of the
object. For example, to implement the Equal trait for Triple you would
write:

    impl Equal for Triple!(A, B, C) {
      ...
    }

The original idea of this syntax was to make it more clear that type
parameters used in the body originated from the object, not the trait.

Over time, I realised that this doesn't actually help and in fact makes
the compiler's life more difficult in a bunch of places. In this commit,
we remove the need for specifying the type parameters, allowing you to
write the following instead:

    impl Equal for Triple {
      ...
    }

Rust 1.41 introduces a new more compact format for Cargo.lock. This
commit takes advantage of that change, and bumps some crate versions
while we're at it.

Modules are now first-class objects in the VM. This allows us to remove
the top-level object, clean up core::bootstrap, and remove
core::globals (in favour of using core::bootstrap directly). As part of
this we also remove Trait.implement(), instead implementing traits using
compiler generated code. Trait.implement() could not be safely used
anyway, as it only copied over default methods; without verifying if all
required methods are implemented.

All of this makes it easier to implement the self-hosting compiler: the
top-level object no longer needs to be supported, and we can treat
core::bootstrap like any other module. This in turn allows us to use a
more efficient way of storing type information in various places.

NilType is now the base object/prototype that Nil is an instance of,
instead of Nil being a direct instance of Object. This allows us to
implement traits and redefine methods on the type of Nil (= NilType),
instead of Nil itself. This in turn allows the compiler to use a more
efficient way of representing types versus instances.

In type signatures you can still use Nil (or NilType, though Nil is
preferred), as this signals that you expect or return something
compatible with Nil, which is only Nil itself.

By introducing the virtual "if" instruction we can clean up Boolean so
that we no longer have to refine the True and False instances. If we
also clean up Nil in a similar way it becomes easier to rewrite the
compiler in Inko, as it no longer needs to support the refining of
random objects.

This was originally introduced in
ecd11a07, but later reverted. In this
commit we re-introduce these changes. Refining True and False makes
various compiler internals in the self-hosting compiler less efficient,
as it has to support refining any object even when this only happens for
True, False, and Nil. By cleaning up True and False we can reduce this
down to just Nil, making it easier to find a way of cleaning that up
too.

With the release of shared Windows runners on GitLab.com, using runners
with _just_ the "windows" tag results in CI using these shared runners.
The shared runners don't have the right software installed, and are
still in beta. To prevent using these, we now also require the runners
to specify the "inko" tag.

This removes support for syntax such as `A::B` where `A` and `B` are
constants. Inko has not allowed defining nested types or constants in
types for a while, and this syntax was only used in a few places to
bootstrap the runtime. Removing support for this syntax simplifies both
the parser and compiler quite a bit.

This keeps the type consistent with other AST nodes such as
DefineMethod.

By just using the VM's built-in panic handler (which now produces the
same output) we can simplify std::vm, and we no longer need to import it
in std::prelude.

This includes the removal/correction of a few outdated comments.

The method Array.reverse_iter returns an Iterator that iterates over the
values in an Array in reverse order.

Now that the Ruby compiler defines types using multiple passes, there no
longer is a need for forward declaring and extending traits. Extending
traits could also lead to odd behaviour when adding default methods. For
example:

    trait A {}

    object Foo {}

    impl A for Foo {}

    trait A {
      def thing -> Integer {
        10
      }
    }

Here type "Foo" would not have access to method "thing", because it is
added after "A" is implemented for "Foo".

Removing support for this entirely solves this problem, and we no longer
need it anyway.

This is no longer needed now that the Ruby compiler defines types in
multiple passes.

This ensures all these nodes use the same naming pattern
(DefineAttribute, DefineMethod, etc), instead of sometimes being called
DefineX while other times being called XDefinition.

This adds very basic (and super hacky) support for circular types to the
Ruby compiler, which should be _just_ enough to allow us to continue
work on the self-hosting compiler. Circular types can arise as follows:

    object TypeParameter {
      @required_traits: Array!(TraitType)
    }

    object TraitType {
      @type_parameters: Array!(TypeParameter)
    }

Without support for circular types code like this won't compile.

The changes needed to make this work are a total hack, and in some cases
will lead to some duplicate work being done (with the results being
discarded). Since this code will only stick around briefly, this is fine
for now.

This was technically already supported, but would trigger a panic for
non-permanent objects. By allowing the hashing of any object we simplify
the API, and make it easier to hash complex objects without having to
manually implement the Hash trait for such structures.

I thought this would make the self-hosting compiler easier to implement,
but it turns out this may not be the case. If we use two objects per
type (one for the "class" and one for the instance), then yes it will
clean things up. But this two object approach complicates the compiler
in various other places. Balancing the two, I prefer being able to
refine random objects as this means fewer VM changes are needed for for
example Boolean and Nil.

Nil is still the singleton instance, but its prototype is set to NilType
instead of Object. By splitting Nil this way we no longer refine
instances of ad-hoc instances, instead only refining objects defined
directly using the `object` keyword.

By introducing the virtual "if" instruction we can clean up Boolean so
that we no longer have to refine the True and False instances. If we
also clean up Nil in a similar way it becomes easier to rewrite the
compiler in Inko, as it no longer needs to support the refining of
random objects.

This ensures we use the same naming pattern for modules used to provide
the building blocks of other modules (std::fs::file for example).

This method can be used to obtain a Path pointing to the directory of
another Path, without touching the file system. A simple example:

    import std::fs::path::Path

    Path.new('/foo/bar/baz').directory.to_string # => '/foo/bar'

The internals of Path.directory depend on the newly introduced
std::fs::path::bits module. This module will be used for defining
internal methods used as the building blocks of the Path type. This
allows us to offload work to separate methods (so we can return early
where needed), without exposing all this in the public API of
std::fs::path.

String.slice_bytes() can be used to slice a String into a ByteArray,
similar to String.slice():

    'foo'.slice_bytes(start: 0, length: 2).to_string # => 'fo'

String.split() can be used to split a string into an Array of
substrings:

    'foo/bar/baz'.split('/') # => Array.new('foo', 'bar', 'baz')

Ever since Integer.format has been introduced there no longer is a
reason to have the VM format the identifier as a string. Using an
integer also saves a heap allocation for cases where we don't need/want
a string.

This is a pretty big refactor of std::mirror to make it entirely
optional. As part of this std::format has been refactored as well, and
all implementations of the Inspect trait (now called Format) have been
moved into std::mirror.

Formatting objects is now part of std::mirror as that's where it
belongs, since the output is often based on the internal representation
of an object. The new API for pretty printing objects is a bit more
verbose, but not that much:

    import std::mirror

    10.mirror.inspect # => '10'

All of this means that the only module currently using std::module is
std::test::assert, which needs std::mirror to produce useful test
failures. Other code that previously used "inspect" has been refactored
to no longer depend on it.

The desired string format for a CallFrame may differ between
applications using it. Inko itself does not use CallFrame.to_string
either, so let's just get rid of it.

The compiler needs support for circular types (e.g. A depending on B and
B depending on A). The way ByteArray was set up in std::byte_array meant
this could not be done with multiple passes, as the assignment of the
`ByteArray` constant would require full type-inference too early in the
compilation process. Moving ByteArray to the prelude and setting it up
while bootstrapping simplifies this, and makes it easier for the user to
use byte arrays.

Void is confusing as in C it's used for void* pointers, which are more
akin to dynamically typed pointers. The name Never more clearly
indicates that something (e.g. returning) will never happen.

This may be a bit redundant for very simple examples such as
`Pair.new(10, 20)`, but it keeps the code consistent with the pattern of
using keywords whenever more than one argument is passed.

This way the standard library relies less on dynamic return types, using
them only where the return type is truly dynamic.