Clean up top-level build file and build options, fix build issues on MinGW

Write defines into a disk file instead of passing 100s of them on the command line directly. Fixes some issues with build commands on my machine, and makes it a lot easier to view the make VERBOSE=1 output.

Switch mbed-baremetal and mbed-os to be OBJECT libraries. Can reuse the existing create_distro function for this.

CMake: Fix command line too long with Ninja/ARMClang on Windows ...

The issue is reported in:
https://github.com/ARMmbed/mbed-os/issues/14533

And relies on bugfix in newer cmake version:
https://gitlab.kitware.com/cmake/cmake/-/issues/21093

CMake: Set TARGET_NAME macro ...

The C/C++ macro `TARGET_NAME` allows code to print the current
target's name, e.g. in error reporting when a fault happens. This
macro is exported by Mbed CLI 1 and used by mbed_error.c, so for
compatibility we let CMake set the same name of macro.

Fixes ARMmbed/mbed-tools#313

CMake: Use CMAKE_MODULE_PATH to locate nuvoton post build hook ...

We were previously relying on the global MBED_PATH variable to provide
the root for the include path to the post build hooks. We can't
guarantee that MBED_PATH will be set by any application building us, so
use CMAKE_MODULE_PATH (which we always set) like we do for the other
post-build hooks.

CMake: greentea: Set variables usually defined by external apps ...

We rely on external applications to set MBED_CONFIG_PATH and include
app.cmake. Mbed OS can't build for a target without those parameters
set. When building greentea tests there is no external application. So,
we define the appropriate settings in our root CMakeLists.txt for
greentea tests.

CMake: Add option to enable greentea tests ...

Add an option to enable the greentea tests independently from the unit
tests.

We can't just use the typical BUILD_TESTING option to enable greentea
tests. BUILD_TESTING enables unit tests and fetches googletest, which
are compiled for the host. Greentea tests are cross compiled and require
a toolchain file. For this reason we add a new option just to enable
greentea tests, preventing build failures triggered by the unit tests
and googletest.

Rework post-build to support multiple executables ...

When building greentea tests, each test is an executable with its
own output binary path. This is also the case when a user project
produces multiple executables. But the current implementation of
post-build operations always assumes there's only one executable,
at the root of the build directory.

The post-build command depends on Mbed target, and it always takes
the the executable we build as an input file. To achieve this, we
let each Mbed target (that has a post-build command) define a function

    function(mbed_post_build_function target)

which takes a CMake executable target as an argument from which it can
get its binary path using generator expressions. It generates and adds
to the passed executable target a post-build custom command.

Notes:
* The function name needs to be exact, because CMake only supports
literal function calls - CMake can't dereference a function name from
a variable. To avoid multiple definitions of this function, each Mbed
target needs to guard it with a macro to check if the user is
building this Mbed target.
* `mbed_post_build_function()` is a function, but it is usually
defined by another macro rather than a parent function, because
nesting functions would make many variables inaccessible inside the
innermost `mbed_post_build_function()`.
* There's no more need to force regenerate images. Previously, post-
build commands were custom *targets* which always got to run, so we
force regenerated images on every build to avoid patching an image
that's already been patched once on previous build. Now post-build
commands are custom *commands* of the same executable target, and they
are only run if the executable target itself is rebuilt.

CMake: Move post build functions out of root CMakeLists.txt ...

The 'post build' functions are made visible by adding the mbed-os
subdirectory. This is not ideal as any components in mbed-os wishing to
call the functions must be added after the functions are defined. To
improve modularity move these functions to a separate CMake script.

We include the post build CMake script in app.cmake for now so we don't
break user's projects.

Merge pull request #14870 from ARMmbed/move_rtos_stub_headers ...

CMake: Remove mbed-stubs-rtos-headers library

CMake: Remove mbed-stubs-rtos-headers library ...

- Previous changes moved all rtos stubs headers into mbed-stubs-rtos-headers
lib, but the decision to keep all stubs headers under the respective
component stubs library so moved all stubs rtos headers under
mbed-stubs-rtos and updated it depend component CMake
- Remove unnecessary add_definition call for UNITTEST as any of the stubs library
added from UNITTEST/CMakeLists.txt is not required this macro

cmake: Set MBED_TEST_MODE with INTERFACE ...

Set MBED_TEST_MODE with INTERFACE. Use INTERFACE because mbed-os is an
interface target, and we can only set INTERFACE properties on interface
targets. This helps avoid the following error when building an
application.

    CMake Error at mbed-os/CMakeLists.txt:96 (target_compile_definitions):
      target_compile_definitions may only set INTERFACE properties on INTERFACE
        targets

Add external greentea-client dependency ...

Use FetchContent to obtain greentea-client at version XXX.

CMake: Remove trailing whitespace from CMakeLists.txt

CMake: Remove forgotten debug message ...

A debug message to display the selected toolchain was left in
the main CMakeLists.txt file. This commit removes it.

Merge pull request #14426 from ARMmbed/feature_unittest_refactor ...

CMake: Refactor UNITTESTS CMake

CMake: Move CMAKE_CROSSCOMPILING check inside library CMake

CMake: Only force Ninja response files on Windows ...

We force Ninja to create response files to work around file path length
limitations on Windows. Previously we were forcing the response file
generation for all platforms, unless we were building on Windows using
ARMClang, this was to work around a CMake issue
https://gitlab.kitware.com/cmake/cmake/-/issues/21093

Unfortunately `ar` on macOS doesn't support Ninja response files. So the
check was incorrect, as forcing a response file to be generated on macOS
causes a build failure when trying to build Mbed's unit tests.

This PR changes the logic so we only generate a response file on Windows
systems if we're not building with ARMClang.

Fix missing newline

CMake: Update mbed os, unittest CMake and add CMAKE_CROSSCOMPILING guard ...

- Add a new MbedOS project in mbed os root CMake which can be used along with
  BUILD_TESTING conditional check for enabling the unittest build
- Update UNITTEST CMake for setting the CMake configuration like c, cxx flags etc.,
- Add if CMAKE_CROSSCOMPILING conditional check wherever target configuration check
  and toolchain configuration to avoid such configuration gets included for unittest build.

Cmake: Add backward compatibilty support for MBED_TEST_MODE ...

Fixes #14494

MBED_TEST_MODE is required for backward compatibilty with CLI1. This
adds a test to ensure that the macro is created when using CLI2 for
testing. This also adds a test in `.travis.yml` that checks whether
CMake defines the macro when BUILD_TESTING is on.

CLI1 Reference: https://os.mbed.com/docs/mbed-os/v6.9/debug-test/greentea-for-testing-applications.html

Also, explicitly create and set the macro BUILD_TESTING to allow for
MBED_TEST_MODE to be defined by CMake. MBED_TEST_MODE is required for
backward compatibilty with CLI1.  BUILD_TESTING is used to determine
whether to define MBED_TEST_MODE.  Normally, this would be automatically
done by CTest (which we intend to add for test automation) but this
hasn't yet been added to our Greentea tests.

CMake: set CMAKE_MODULE_PATH in the Mbed OS CMakelists.txt ...

Update CMAKE_MODULE_PATH at once place.

Note, we update also CMAKE_MODULE_PATH in app.cmake. This is temporary until we get a proper way to include
Mbed Os (removing app.cmake need to be included by an application).

CMake: add mbed_ prefix to our CMake files ...

To avoid conflicts as we expose our CMake list files via CMAKE_MODULE_PATH. Some files already include it, this
aligns the rest of files.

I leave app.cmake as it is - it's user facing and it would be breaking change. We can clean this one for the next major version.

CMake tools: use CMAKE_CURRENT_LIST_DIR instead of MBED_PATH ...

Excluding greentea tests, they will be fixed separately (more work needed).

CMake: use project name for Mbed OS ...

This enables multiple variables we can use. One of them is source dir for a project.

It will replace MBED_PATH in the tree.

CMake: Image format based on MBED_OUTPUT_EXT ...

Requires: https://github.com/ARMmbed/mbed-tools/pull/242

The optional `OUTPUT_EXT` field in Mbed OS `targets.json` specifies
the format of the output image. This is important because
* some targets only support one image format
* each post-binary hook outputs one image only

This avoids confusion of having both .hex and .bin images generated
while only one of them is usable.

CMake: pass application name to post-build hook ...

Pass the exact name to the post-build hook, when an application's
or test's `CMakeLists.txt` calls `mbed_set_post_build()`. The
interface is CMake's built-in mechanism:
* `set_target_properties()` to set a property, e.g. application name
* `$<TARGET_PROPERTY:target,property>` to query a property at run time

Force regenerate application binaries on rebuild ...

If a target has a post binary hook, we should force regenerate
the application binaries every time so that the hook is run on a
raw binary rather than a previous build that already went through
the post-build process once.

Configure memory map per target to allow multiple add_executable