(#22363) Fix problems in TypeParser

The TypeParser misinterpreted several types as being ResourceType
if an attempt was made to parameterize a non parameterized type.

The type Object is now also supported.

When the TypeParser was used to only interpret it failed when
there was an error - this because the type parser was not used
to parse the original string. All ast objects have a Locator when
they come from the future parser and it holds the parsed string.
Now, the string is obtained from the locator if not originally
parsed via the type parser. (This should be cleaned up later).
(#22363) Fix problem with reversal of compare <, > of types

The logic was reversed compared to Ruby. Object > Integer should be
true with the rational that the set of all objects > the set of all
integers. The evaluator impl had this wrong.
(#22363) Fix issues with type comparisons

Integer type equality was broken (always true).
Literal type missing in type parser.
Literal type not considered to be Data

Adds test.
(#22363) Add additional Integer range tests
(#22363) Add capability to match against Type

Using the match operator with a Type RHS performs a puppet
instance? test
(#22363) Make access with [] also work for class parameters
(#22363) Make test for [] on Class to get parameter really work

The test was botched, it needed to do an import_ast to get class
initialized, and then evaluate its code, not the class itself.

A test in access_ops no longer works (the semantics of [] changed) and
access_ops is not instrumented to do full code import. (The test
is now in evaluating_parser_spec instead).

The e4_parser_adapter was to eager to report a .rb file as being
not supported (it should have checked if it was in "string mode" before
failing).

PopsBridge had a typo.
(#22363) Handle failing tests due to renamed collect/map

Collect/map was renamed, but there were tests that still used
collect. One test was broken in map_spec.rb (due to fix of undef/nil
problem that was missed in rename/merge/rebase).
(#22363) Rename box_numeric to coerce_numeric

There is no "boxing" going on in Ruby (since there are no native
data types). The term 'coerce' is much better for this.
(#22363) Port use of FileSystem to Lexer2

The regular lexer was modified to use the FileSystem when checking
for file existence. This is no ported to Lexer2
(#22363) Add strict variable lookup mode

This adds the setting :strict_variables. When used the scope
will throw :unkown_variable (which if not handled, will raise
an exception). The future evaluator can handle this, but none of
the other parsers/evaluator options. Testing of the future evaluator
turns on strict variables mode (and has tests that an error is raised).

This commit also contains maintenance (removal of unused code), fixing
of the pops bridge (special case when evaluating without a proper boot)
(#22363) Add test that literal type can be interpolated

Test that "interpolate ${Array[Integer]}" works (results in
the type in string form).
(#22363) Add tests for [] without keys and unsupported LHS => error
(maint) Refactor evaluating parser tests

Duplicated context, tests outside of context moved.
(#22363) Add relationship test

This also fixes problems with relationship evaluation.
(#22363) Fix problem with integer string to Integer on Ruby 1.8.7

The problem was caused by the logic using the Kernel method
Integer(string, radix) which was introduced in Ruby 1.9.2. We do
not need to pass radix, since the string converted starts with 0, 0x,
or 0X in all cases.
(#22363) Make string and array access operation work as specified.

The implementation relied on Ruby to do the right thing for both
String and Array slice operations. Naturally there were differences
between Ruby 1.8.7 and Ruby 1.9.2. This lead to a revisit of the
specification and a more solid implementation.

For string, a string is always produced (never undef). For array, undef
is produced if a single element is requested (without count) and the
index is outside of range. For a subarray of any length, including 0, an
empty array is always produced if the given range is outside of the
array's range.

For both string and array, a negative start index enumerates from the
end, and a negative count computes the wanted range using first an end
enumeration, and then a computed count (start_index to end_index), if
this is an inverse range (extending to the "left", or if the range is
outside, an empty array / empty string is produced.

In both cases, if there is partial overlap to the left or the right,
the overlapping range is produced.
(#22363) Fix failing tests on Ruby 1.8.7

Tests that depended on hash having a defined order failed on
Ruby 1.8.7. This corrects the failing tests.
(#22363) Refactor Type system, add Enum, Regexp, and Variant

This changes the existing Pattern class to Regexp, and introduces
a new Pattern class to describe a subset of strings based on
a regular expression. An Enum type descriebs the set of strings
equal to one of its values. A Variant type is disjoint set of types
that describes instance of one of its types.

The type calculator tests have been refactored for better
maintainability.

The operation [] on a (old) Pattern type, now Regexp) was changed
to not produce an instance of Regexp, instead Regexp[s] produces a
narrow type that can be used instead of a regular expression in matches.
(#22363) Add alternative Visitor impl that may prove faster

This adds an alternative Visitor implementation that may prove
to be faster in certain situations. The current benchmarks are
however too simplistic to give a good indication. It seems to be
on par with the previous implementation for simple cases. It is
worth keeping this implementation for later use with larger benchmarks.