Variables - a.k.a. Named Parameters - #1799

A named parameter's value can be an expression that uses the named
parameters of earlier groups. The expression is kept in the new
Request::expression field, saved only when it isn't empty, and the
parameter's value is set from it on every regeneration, before its group
is solved. A parameter with an expression is always locked. Each group
now also keeps inheritedParamNames, the names of earlier groups, which
these expressions are parsed against, so they can't use names from their
own group.

If a parameter's expression uses a name that isn't defined, the parameter
keeps its last value, its group fails with UNKNOWN_NAME, and the group's
page shows the expression in the error color, with the reason as a
tooltip. The failure page lists such parameters along with any dimensions
that use undefined names.

An unknown-name failure now takes the text window to the group's failure
page only when it first happens. While a group keeps failing for the same
reason, regenerating leaves the user on the page they are on, so they can
add the missing name back.

The parameter rows in a group's page are laid out in columns: a lock icon
that locks or frees the parameter, the name, the value (or expression),
and [change] and [del] links. Names longer than the column are shortened,
with the whole name as a tooltip. The lock icons are new glyphs in the
private use area, and the text window can now show a tooltip for any text,
with %T in Printf().

A new named parameter starts with a value of 5.

A relation is a new constraint type, placed and drawn like a comment: at
a selected point, or where the user clicks next. It is in the Constrain
menu, with the '/' key, and in the toolbar with a new icon. Its text can
be edited like a comment's; it doesn't generate any equations yet.

A relation's text, kept in Constraint::expression, is an equation such as
"w*h = 400". It is split at the '=', and each side is parsed as an
expression that can use the named parameters in scope in its group; the
relation generates the one equation left - right = 0. Free parameters of
the group are solved for; those of earlier groups are constants. A
relation's text needs no units scale, since named parameters are unitless.

When a relation is typed, it must have exactly one '=', an expression on
each side, and use at least one named parameter; the group's degrees of
freedom are checked again. A new relation has no text, shows
"NEW RELATION -- DOUBLE-CLICK TO EDIT", and generates no equation until
it is edited. A relation that uses a name that isn't defined is reported
with the UNKNOWN_NAME solve result, like a dimension.

A relation isn't a dimension: it can't be made a reference, it still
applies when all of a group's dimensions are reference, and it can't be
stepped. Relations are copied and pasted like comments, and shown as
RELATION when selected.

Co-authored-by: Dhruv Gramopadhye <dgramopadhye@gmail.com>

When a dimension or relation is typed with names that aren't defined in
its group, those names become new free named parameters in that group,
as if they had been added in the text window. The text is first checked
as though the names existed, so nothing is created if it isn't otherwise
valid. The parameters are created in the same undo step as the edit, and
a message lists them, so that a mistyped name is noticed.

A dimension that is just one new name starts it at the dimension's
current value, in the units it was typed in, so nothing moves; other new
parameters start at the default value.

Names are only created when a constraint is typed. A name that later
goes missing is still reported as unknown.

Expr::FindUndefinedNames() finds the names, reading the text the way the
parser does, and Constraint::CreateNamedParams() creates the parameters.