Add failing test for proposed %skip property.
Add failing test for proposed %skip property.

The %skip property should control the parsing process of units. Consider the
example of parsing simple arithmetic comparisons of the form "LHS OP RHS" where
the whitespace between the tokens is some form of whitespace irrelevant to the
semantics of the expression. A BinPac unit may look like this:

        export type foo = unit {
          lhs : /[a-z]+/;
          op  : /[<=>]/;
          rhs : /[0-9]+/;
        };

Here, however, the whitespace is omitted. But without specifying it, parsing
would not succeed. As a grammar writer, it would be nice to have a feature to
control the consumption of semantically irrelevant input. To this end, I
propose the notion of a "skip" property. There exist two forms of skippinp:
module-wide or per-unit. In the per-unit case, grammar writers can annotate
their unit as follows:

        export type foo = unit {
          %skip-pre = /[\t\n ]+/;
          %skip-post = / +/;

          lhs : /[a-z]+/;
          op  : /[<=>]/;
          rhs : /[0-9]+/;
        };

The two properties %skip-pre and %skip post "decorate" each field in a unit
with by either adding an invisible field beforehand (pre) or afterwards (post).
The internal representation of a unit may look now similar to:

        export type foo = unit {
          __pre_lhs : /[\t\n ]+/;
          lhs : /[a-z]+/;
          __post_lhs : / +/;
          __pre_op : /[\t\n ]+/;
          op  : /[<=>]/;
          __post_op : / +/;
          __pre_rhs : /[\t\n ]+/;
          rhs : /[0-9]+/;
          __post_rhs : / +/;
        };

The __* fields shall not be accessible by users but keep the skipped input for
later generation.

For example, consider the following inputs:

  (1) "a=0"
  (2) "x < 0"
  (3) " x > 0 "
  (4) "\nm\n=\n42"

In (1) no skipping takes place. (2) skips with __post_lhs and __post_op.
(3) skips the same as (2) but additionally with __pre_lhs and __post_rhs.
(4) skips with all versions of __pre_*.

Module-wide skipping shall work similarly:

        Module WS;
        const whitespace = /[\t\n ]+/;
        %skip-pre = whitespace;

        export type foo = unit { ... };
        export type bar = unit { ... };

Both types foo and bar inherit the module-wide %skip-pre property. To
selectively disable skpping inside a unit, one has to nullify the property
explicitly:

        export type baz = unit {
          %skip-pre = None;
          ...
        };

FrozenCaribou/hilti,rsmmr/hilti,FrozenCaribou/hilti,FrozenCaribou/hilti,rsmmr/hilti,rsmmr/hilti,rsmmr/hilti,rsmmr/hilti,FrozenCaribou/hilti,FrozenCaribou/hilti