At the moment, we are guessing whether we have the MSVC compiler, by
looking at what Python was originally compiled for.  That works only if
we are using the same compiler, but this is not the case when we compile
with e.g. mingw-w64 using Python.org Python.

Unfortunately, at the time we are specifying build flags, we don't know
what compiler we are using.

Allow build flags to clib to be callables that return lists of strings,
instead of strings, where the callables can do work like inspecting the
compiler, at build time.

Use this to check for MSVC at build time, when specifying the
`/GL-` flag.

See gh-9977 for a related discussion about these flags.

This is just a technical prototype to measure and discuss the impact and
implication of moving to C++ for kernel code generation.

  The bug can occur only if the build option `build`
  was passed before the option `bdist_wheel`.

  You may still realize a duplicate printing for the compiler
  optimization report in the build log, which is normal due to
  multiple calling of command `build` by setuptools.

  The error appears when option `build` is represented
  before `bdist_wheel`.

    Same usage as the C dispatch-able sources except files extensions
    should be `.dispatcher.cpp` or `.dispatch.cxx` rather than `.dispatch.c`

  The new path becomes `build/src.*/numpy/distutils/include/npy_cpu_dispatch_config.h`
  instead of `numpy/core/src/common/_cpu_dispatch.h`.

  The new path allows other projects to re-use the CPU dispatcher
  once we decide to expose the following headers:
    - `numpy/core/src/common/npy_cpu_dispatch.h`
    - `numpy/core/src/common/npy_cpu_features.h`

  This patch also cleans up `CCompilerOpt` calls in build_ext and build_clib.

  - Put `CCompilerOpt` in action through add two command line
    arguments that passed directly to `CCompilerOpt`'s
    parameters which explained as follows:

    * `--cpu-baseline` minimal set of required optimizations,
      default is 'min' which provides the minimum CPU features
      that can safely run on a wide range of users platforms.

    * `--cpu-dispatch` dispatched set of additional optimizations,
      default is 'max-xop-fma4' which enables all CPU features,
      except for AMD legacy features.

    the new arguments can be reached from `build`, `build_clib`,
    `build_ext`, if `build_clib` or `build_ext` are not specified
    by the user the arguments of `build` will be used, which also
    hold the default values.

  - Activate the new compiler dispatcher that comes with `CCompilerOpt`,
    through adding a hock inside `build_clib` and `build_ext`
    that works as a filter taking any C source files ends with
    `.dispatch.c` and pass it directly to `CCompilerOpt` and
    then take returned objects and linked to the final C lib.

  - Add a third command-line argument `--disable-optimization` which
    explicitly disable the whole new infrastructure, also
    It adds a new compiler definition called `NPY_DISABLE_OPTIMIZATION`.

    when `--disable-optimization` is enabled the dispatch-able sources
    that end with `.dispatch.c` will be treated as a normal
    C sources, also due to this disabling any C headers that
    generated by `CCompilerOpt` must guard it with `NPY_DISABLE_OPTIMIZATION`,
    otherwise, it will definitely break the build.

  - New auto-generated C header located at `core/include/numpy/_cpu_dispatch.h`,
    the new header contains all definitions and headers of CPU features that
    enabled according to specified configuration in `--cpu-baseline`
    and `--cpu-dispatch`.

* Cleanup unused imports (F401) of mostly standard Python modules,
  or some internal but unlikely referenced modules
* Where internal imports are potentially used, mark with noqa
* Avoid redefinition of imports (F811)