Implement a CMake build system.

This is a large rework of my first attempt at this (#459).

This implementation calls into the recently implemented python scripts
to generate the necessary generated ``.h`` and ``.cpp`` files but is
independent from Python building system otherwise.  Unlike the Python
build system, the generated files are emitted into the build tree to
avoid polluting the source tree. The build system is setup to refuse to
configure if it detects generated files in the source tree. If your
source tree is dirty you can run ``git clean -fx`` to clean your working
directory.

Currently the build succeeds on Linux using CMake 3.4.3 using
the "Unix Makefiles" generator with gcc or clang.

The following notable features are implemented:

* Building of the C and C++ examples and the ``test-z3`` executable.
  These are included from the ``all`` target so you have to tell the
  build system (e.g. make) to build them manually.

* Install (``make install``) and uninstall (``make uninstall``) of libz3
  and its header files. This supports ``DESTDIR`` out of the box because
  CMake supports it.

* An option (``BUILD_LIBZ3_SHARED``) to build libz3 as a static or dynamic library.

* Support for using/not using OpenMP (``USE_OPENMP``)

* Support for using/not using libgmp (``USE_LIB_GMP``)

* Setting the SOVERSION for libz3. I'm not sure if I'm setting the
* number correctly though. This is required by Linux distrubtions that
  wills ship libz3. This needs discussion.

The following notable features are currently not implemented
and are left for future work.

* Support for ARM.
* Support for the foci2 library.
* Support for creating/installing/uninstalling the dotnet, java, python and ml
  bindings.
* Full support for MSVC. Although I've tried to write the CMake code
  with MSVC in mind not all the correct flags are passed to it.
* Support for using the git hash.

This new build system has several advantages other the old build system.

* It is easier for outside contributors to contribute to Z3 when the
  build system is something more standard.
* Incremental builds work properly. With the old build system when
  new code is pulled down the old build directory would need to thrown
  out and a new fresh build had to be performed because the build system
  didn't know how to correctly rebuild the project (e.g. couldn't handle
  new sources being added/removed, compiler flags changing, generated
  files changing, etc...). This is a MASSIVE boost to productivity!
* We now have access rich array of features that CMake provides for
  building C/C++ projects. This means less time spent implementing
  custom build system logic in Python that is already supported by
  CMake.
* CMake supports many IDEs out of the box so it should be fairly
  straight forward to build Z3 with Visual Studio (once support for MSVC
  is added), Xcode, Eclipse CDT, CLion, ..etc.

src/shell/CMakeLists.txt

@@ -0,0 +1,47 @@
+set (shell_object_files "")
+# FIXME: z3 should really link against libz3 and not the
+# individual components. Several things prevent us from
+# doing this
+# * The api_dll component in libz3 shouldn't be used the
+#   the z3 executable.
+# * The z3 executable uses symbols that are hidden in libz3
+
+# We are only using these dependencies to enforce a build
+# order. We don't use this list for actual linking.
+set(shell_deps api extra_cmds opt sat)
+z3_expand_dependencies(shell_expanded_deps ${shell_deps})
+get_property(Z3_LIBZ3_COMPONENTS_LIST GLOBAL PROPERTY Z3_LIBZ3_COMPONENTS)
+foreach (component ${Z3_LIBZ3_COMPONENTS_LIST})
+  if ("${component}" STREQUAL "api_dll")
+    # We don't use the api_dll component in the Z3 executable
+    continue()
+  endif()
+  list(APPEND shell_object_files $<TARGET_OBJECTS:${component}>)
+endforeach()
+add_executable(shell
+  datalog_frontend.cpp
+  dimacs_frontend.cpp
+  "${CMAKE_CURRENT_BINARY_DIR}/gparams_register_modules.cpp"
+  "${CMAKE_CURRENT_BINARY_DIR}/install_tactic.cpp"
+  main.cpp
+  "${CMAKE_CURRENT_BINARY_DIR}/mem_initializer.cpp"
+  opt_frontend.cpp
+  smtlib_frontend.cpp
+  z3_log_frontend.cpp
+# FIXME: shell should really link against libz3 but it can't due to requiring
+# use of some hidden symbols. Also libz3 has the ``api_dll`` component which
+# we don't want (I think).
+  ${shell_object_files}
+)
+z3_add_install_tactic_rule(${shell_deps})
+z3_add_memory_initializer_rule(${shell_deps})
+z3_add_gparams_register_modules_rule(${shell_deps})
+set_target_properties(shell PROPERTIES OUTPUT_NAME z3)
+target_compile_definitions(shell PRIVATE ${Z3_COMPONENT_CXX_DEFINES})
+target_compile_options(shell PRIVATE ${Z3_COMPONENT_CXX_FLAGS})
+target_include_directories(shell PRIVATE ${Z3_COMPONENT_EXTRA_INCLUDE_DIRS})
+target_link_libraries(shell PRIVATE ${Z3_DEPENDENT_LIBS})
+z3_add_component_dependencies_to_target(shell ${shell_expanded_deps})
+install(TARGETS shell
+  RUNTIME DESTINATION "${Z3_INSTALL_BIN_DIR}"
+)