Prototype for span-based ASTs

[Hirevo]

This PR experiments with refactoring the lexer and the parser to entirely rely on spans, instead of directly constructing values.
This makes the construction of the AST a bit more efficient, since it reduces the number of allocations needed.

The interpreter then takes the AST and can resolve spans to string slices (an efficient non-owning view into a string) when needed, by keeping around the source code for each class definitions.

It opens the door for better error-reporting, allowing to show proper stack-traces to the user (although not done here yet and probably not within the scope of this PR).
But it also means that things like integer literals need to be parsed into actual integers every time we evaluate one.

I haven't done any measurements yet on the performance delta with the original implementation, so I cannot say if this is an actual improvement over it.

The implementation should already be feature-complete and in parity with the features of the original interpreter.

[smarr]

But it also means that things like integer literals need to be parsed into actual integers every time we evaluate one.

Hm, could you simply cache the results after the first evaluation?
Re-parsing things like integers and string seems like something potentially expensive, for instance when done in a loop:

| cnt |
1 to: 1000 do: [:i |
  cnt := cnt + 1. "Is this 1 always reparsed?" ].