Add class cmRST to do basic reStructuredText processing

Create a cmRST class to perform just enough reStructuredText processing
to support display of Help documents in human-readable text format.
This will be used to implement --help-* command-line options.

Support directives "include", "replace", "parsed-literal", "toctree"
(Sphinx), and "cmake-module" (CMake Sphinx Extension to scan .cmake
modules).  Support inline CMake Sphinx Domain roles to convert
cross-references to corresponding title text.  Support inline
substitutions defined by the "replace" directive, but keep it simple by
requiring replacements to be defined before use.

Add a CMakeLib "testRST" case to cover processing of supported
constructs and compare results against expected output.
Teach --help-* options to load documentation from .rst files

Install the Help directory next to Modules to make it available in CMake
distributions.  Use cmRST to read Help .rst documents and print them as
help output.

Add options

 --help-manual-list
 --help-manual

to list available manuals or print one of them.  Implement the options

 --help-commands
 --help-modules
 --help-policies
 --help-properties
 --help-variables

by mapping to the corresponding manual page.  Implement the options

 --help-command-list
 --help-module-list
 --help-policy-list
 --help-property-list
 --help-variable-list

by globbing the available Help .rst documents of the corresponding type
and reading their titles.  Implement the options

 --help-command
 --help-module
 --help-policy
 --help-property
 --help-variable

by globbing the matching Help .rst document(s) and printing them.
Teach COMPATIBLE_INTERFACE_* checks to use Help .rst documents

These checks want to know if named target properties are builtin, which
is now known by checking the Help/prop_tgt directory.  (Previously the
check could be confused by a define_property call in the project.)
Drop all documentation formatters except Usage

We now need only the Usage formatter to support command-line options
that print basic usage, and the supporting indented=>preformatted markup
processor to support CMake message formatting.  Drop all other
documentation formatters and move the remaining code up into the top
cmDocumentationFormatter class.
get_property: Drop test for builtin property documentation

Property documentation is no longer builtin, so the get_property command
will be unable to return the documentation.  Drop the test for it.
Drop builtin property documentation

Drop all DefineProperty calls for non-chained properties.  Drop the
documentation from the chained ones.  The documentation for all
properties is now in Help/prop_*/*.rst files.
Drop builtin command documentation

Drop all GetTerseDocumentation and GetFullDocumentation methods from
commands.  The command documentation is now in Help/command/*.rst files.
Drop the 'Full' field from cmDocumentationEntry

We need only 'Brief' for usage documentation.  We no longer have builtin
'Full' documentation, which is now in Help/*/*.rst files.
Drop unused builtin documentation APIs

Now that all DefineProperty documentation calls have been dropped, drop
the supporting APIs.
Build Help documentation during CMake build using Sphinx

Add a Utilities/Sphinx directory to hold CMake build code to run the
Sphinx (sphinx-doc.org) documentation generation tool.  Create a
CMakeLists.txt file there capable of building either as a subdirectory
of the main CMake build, or as a standalone documentation build.

Add cache options SPHINX_MAN and SPHINX_HTML to select output formats
and SPHINX_EXECUTABLE to specify the sphinx-build executable.  Add
bootstrap options --sphix-man and --sphinx-html to select output formats
and --sphinx-build=<sb> to specify the sphinx-build executable.

Create a "conf.py.in" file to configure_file into "conf.py" to tell
sphinx-build how to build our documents.  Create a "cmake.py" Sphinx
extension module defining:

* The "cmake-module" directive used in Help/module/*.rst files to
  scan .rst markup from the corresponding Modules/*.cmake file.

* A Sphinx domain called "cmake" defining documentation object types
  for CMake Help/<type> directories: command, generator, manual,
  module, policy, prop_*, and variable.  Add a "role" for each type
  to perform cross-references.  Teach the roles to treat "<XYZ>"
  as placeholders instead of explicit targets if not preceded by
  a space.  Add cmake domain directives to define command and
  variable objects explicitly in .rst file content.  This will
  allow modules to define their own commands and variables and
  have them indexed and linkable.

* A Sphinx document transform that converts Help/<type>/*.rst documents
  into cmake domain objects of the corresponding <type> and adds index
  entries for them.  This will automatically index all CMake documentation
  objects and provide cross-reference targets for them with no special
  markup in the .rst files.
Help: Factor out *_OUTPUT_(NAME|DIRECTORY).rst duplication

Portions of these documents contain duplicate content generated from
preprocessor macros in the original builtin documentation source.
Factor the common parts out into .txt files using reStructuredText
include directives and substitutions to avoid duplication.
Help: Factor out find_* command duplication

These documents were represented in the builtin documentation using a
common starting point with placeholders substituted by each command.
Convert them back to this approach using the reStructuredText include
directive and substitutions to avoid duplication.
Help: Factor out COMPILE_DEFINITIONS disclaimer duplication

The COMPILE_DEFINITIONS escaping disclaimer was represented in builtin
documentation using a preprocessor macro.  Factor the duplicate content
out into a separate .txt file and include it in each document with the
reStructuredText include directive.
Help: Factor out cmake-generator-expressions manual page

Generator expressions are supported in many places and are a distinct
concept worthy of their own manual page.  The old builtin documentation
was previously represented by preprocessor macros to generate it into
each place that supports them.  Factor out the duplicate content into a
dedicated cmake-generator-expressions manual page and reference it from
each original location.
WIP: Convert some CPack module variable docs to .rst

Replace the old #variable/#end markup with cmake domain directives to
explicitly define some variables and their documentation.

This unfinished work serves to demonstrate how to markup variable
documentation in modules.
WIP: Replace old #markup with .rst equivalent

Drop #end and #module.  Convert #section to a subsection header.
Convert #macro to cmake:command:: directive.

Start converting #variable to cmake:variable:: directive.
See CPACK_RPM_POST_INSTALL_SCRIPT_FILE for example of multiple variables
sharing documentation.

This is work in progress!  It makes sense to complete only after the
final conversion of documentation.
WIP: Try out cmake domain object references

Create a few example cross-references using cmake domain roles.

Add some bogus ones to Help/command/add_dependencies.rst just
to illustrate what can be done.
WIP: Add sample html and man pages generated by Sphinx

Try the html pages by pointing a browser at

 html/index.html

Try the man pages on Linux with

 man -l man/cmake-commands.7

Try the command-line help by building and running

 cmake --help-commands |less

or run with one of the other help options.