CTest: create one output file per memcheck (#14303)

The output file used for memory checker runs must be unique for every test run
in parallel, so simply make them unique for every test run. Simply use the test
index to avoid collisions.
Add RunCMake.Syntax test to cover argument parsing

Test basic unquoted and quoted argument parsing cases including failure
on an unterminated string and an unterminated command invocation.  Also
cover arguments not separated by any spaces, which is accidentally
allowed by the current parser.
cmListFileLexer: Fix line number after backslash in string

If a line inside a string ends in a backslash count the following
newline character as a line increment.  Add a test covering this case to
verify that subsequent line numbers are correct.
cmListFileLexer: Split normal and legacy unquoted arguments

Match legacy arguments separately.  Add macros to simplify and clarify
matching rules.
cmListFileArgument: Generalize 'Quoted' bool to 'Delimeter' enum

Replace the boolean value that indicates whether an argument is unquoted
or quoted with a generalized enumeration of possible argument types.
For now "Quoted" and "Unquoted" remain the only types.
Add RunCMake.Syntax test cases for command invocation styles

Cover commands with whitespace present in allowed combinations.
Also cover command error cases such as two on one line.
cmListFileCache: Convert CMake language parser to class

Refactor the parser implementation into a class to make
it easier to extend.
Warn about arguments not separated by whitespace

Teach the lexer to return tokens for whitespace.  Teach the parser to
tolerate the space tokens where whitespace is allowed.  Also teach the
parser to diagnose and warn about cases of quoted arguments followed
immediately by another argument.  This was accidentally allowed
previously, so we only warn.

Update the RunCMake.Syntax test case StringNoSpace expected stderr to
include the warnings.
Warn about unquoted arguments that look like long brackets

In the future CMake will introduce Lua-style long bracket syntax.
Warn about unquoted arguments that in the future will be treated
as opening long brackets.

Teach the RunCMake.Syntax test to cover such cases and ensure that the
warning appears.
cmListFileLexer: Modify flex output to avoid Borland warning

Remove the "yyscanner = NULL" assignment from the end of the
yylex_destroy function because Borland warns that the value is never
used.
variable_watch: Store client data as pointers

The STL containers create extra copies which makes keeping track of the
owner of the client data much messier.
variable_watch: Add a deleter for the client data

The client data is arbitrary and the callback may be called an
unspecified number of times, so the cmVariableWatch must be the one to
delete the client data in the end (if it is needed at all).
variable_watch: Match client_data when finding duplicates

If a callback has the same data as another call, we don't want to delete
the old callback. This is because if the client_data is the same, it
might get deleted causing the new client_data to be bogus. Now, AddWatch
will return true if it will use the watch, false otherwise. Callers
should check the return value to know whether client_data was adopted by
the watch or not.
variable_watch: Allow specifying the data to match in RemoveWatch

Now that watches are dependent on their client_data when adding, it also
makes sense to allow matching the data for removal.
variable_watch: Prevent making extra entries in the watch map

When removing a watch on a variable, using the operator [] on the
internal map will create an empty watch if the variable doesn't have any
existing watches. Rather than creating this empty structure in the map,
return if there isn't a watch on the variable already.
variable_watch: Fix a typo in the error message

There was no space between "callback" and the quoted command name.
variable_watch: Don't share memory for callbacks

The command itself is owned by the cmMakefile class, but the
cmVariableWatch which holds a pointer to the cmVariableWatchCommand via
the client_data for the callback outlives the cmMakefile class in the Qt
GUI. This means that when the cmMakefile is destroyed, the variable
watch is still in effect, but with a stale pointer.

To fix this, each callback is now a separate entity completely and
doesn't rely on the command which spawned it at all.

An example CMakeLists.txt which demonstrates the issue (only displayed
in cmake-gui, so no tests can be written for it):

    set(var 0)
    variable_watch(var)
variable_watch: Check newValue for NULL

On read access, newValue can be NULL since there is no new value, so use
the empty string instead.
variable_watch: Add test for watching a variable multiple times
Merge branch 'dev/fix-variable-watch-crash' into cmake-syntax

Resolve conflict in Source/cmVariableWatchCommand.cxx by integrating the
changes from both sides.