Hide internals of values

[udoprog]

This is the big change for the next major release of Rune.

• The internals of the Value type will be made private, so there will be no way to match over variants.
• Cloning a Value doesn't clone the interior value, effectively meaning that numbers and other primitives are no longer implicitly copy.

Internals of Value are private

This means that we can internally use any signature, giving us more freedom in how the language is evolved in the future. So we eat the breakage now instead.

As a result of this change, Shared is private.

All values are structurally shared

For converting to and from Value, you should prefer to use rune::to_value and rune::from_value.

The second change is necessary to implement many future compiler optimizations, such as this:

let a = expr1;
let b = expr2;
let (a, b) = (b, a);

Preferably a compiler should convert this to:

let a = expr2;
let b = expr1;

However, in a dynamic language the semantics of the tuple assignment depends on whether a and / or b are copy types. The assignment would either copy the underlying values or structurally share the values. This matters if such assignments are later mutated.

This change ensures that the language has a single semantic; all values unless they are explicitly cloned with the clone method are structurally shared. Even numerical values.