Scope based on linear programming. Work in progress.
Refactored and handles refs correctly up to scopes of <50000. For scopes outside this range, the scope analyzer *may* incorrectly claim 'no solution'.
Everything but parent, in and ++
The type system now stores enough type information to check for intersections (useful for upcoming scope analysis).

Also fixed the following bugs:

1. Non-boolean constraints now fail.

  eg.
  [1 - 3]

2. "this" is now handled correctly.

  eg.
  A
    B ?
      C
    [A.B.this.C]

  will now fail.

3. Multiple (implicit) refs are now handled correctly.

  eg.
  A -> B
  B -> C
  C -> int

  [A = B]

  now produces the correct/runnable output.

4. Correctly handles unions of different types.

  eg.
  A
  C -> int

  [(A++C) = 1]

  will now pass type checking (it would fail before) and produce the correct output.

5. If/then/else now correctly handles nonboolean consequents and alternatives.

  eg.
  C -> int
  [(if (C=5) then 3 else 4) = 3]

6. Correctly handles explicit refs

  eg.
  A -> B
  B -> int

  [A.ref.ref = B.ref]

  will produce the correct output
Check for bitwidth against the largest scope and largest integer constant.
Cardinality constraints, global/this paths.
Passes 36/38 test/positive
Passes 37/38 test/positive models.
Merged in changes from the develop branch.
Passes 46/47 test/positive models. The only one it fails telematics.cfr. Not including i78_transitive-closure.cfr nor i84-references-pointing-to-the-same-object.cfr since they both seem to fail for ANY scope I give it.
Fixed for multi level hierarchy trees.

For example, will now compute the minimum scope of the following model:

    abstract A
        Z +
    abstract B : A

    C : B
        [#Z >= 4]

    D : A
        [#Z >= 2]
Calculations for the exclusive inequalities, ">" and "<".

For example:

    A
        B
        [#B > 3]
Correctly computes the minimum scope for all 47/47 test/positive .cfr models!
Improved scope analysis speed.
Solves correctly for expressions that traverse a reference. For example

A
    B -> C *

C *
    D 2

[#A.B.D = 8]

Will now correctly compute that we need #B=4 to make #A.B.D=8 satisfied.
Added scope rules for "implies" where both left hand and right hand expression start with "this".

A 2
    B ?
    C ?
    [this.B => this.C]

[#B = 2]

Now deduces that #C=2.
Correctly solve for references where somewhere along the path it passes through a clafer with * as the upper cardinality.

For example

A *
    B -> C *

C *
    D *
        E*

[#A.B.D.E = 4]

Now correctly computes the scope.
Fixed for simple expression "this".

For example

A *
    [this in D]

D -> A *

[#A = 3]

Will no correctly compute that #D>=#A => #D = 3
Fixed for

R 2
    A
        B -> C *
    [#A.B.D = 8]

C *
    D 2
Fixed for constraints under Clafers that might have 0 scope.

For example:

    A *
        B *
        [#D >= 1]

    D *

Here, #D=0 because the constraint does not affect anything because #B=0