Make test initialization self-registering

Adding or removing tests is a little bit cumbersome currently: the test
needs to be added to CMakeLists.txt, the init function needs to be
predeclared in pybind11_tests.cpp, then called in the plugin
initialization.  While this isn't a big deal for tests that are being
committed, it's more of a hassle when working on some new feature or
test code for which I temporarily only care about building and linking
the test being worked on rather than the entire test suite.

This commit changes tests to self-register their initialization by
having each test initialize a local object (which stores the
initialization function in a static variable).  This makes changing the
set of tests being build easy: one only needs to add or comment out
test names in tests/CMakeLists.txt.

A couple other minor changes that go along with this:

- test_eigen.cpp is now included in the test list, then removed if eigen
  isn't available.  This lets you disable the eigen tests by commenting
  it out, just like all the other tests, but keeps the build working
  without eigen eigen isn't available.  (Also, if it's commented out, we
  don't even bother looking for and reporting the building with/without
  eigen status message).

- pytest is now invoked with all the built test names (with .cpp changed
  to .py) so that it doesn't try to run tests that weren't built.

tests/pybind11_tests.cpp

@@ -10,32 +10,14 @@
 #include "pybind11_tests.h"
 #include "constructor_stats.h"
 
-void init_ex_methods_and_attributes(py::module &);
-void init_ex_python_types(py::module &);
-void init_ex_operator_overloading(py::module &);
-void init_ex_constants_and_functions(py::module &);
-void init_ex_callbacks(py::module &);
-void init_ex_sequences_and_iterators(py::module &);
-void init_ex_buffers(py::module &);
-void init_ex_smart_ptr(py::module &);
-void init_ex_modules(py::module &);
-void init_ex_numpy_vectorize(py::module &);
-void init_ex_arg_keywords_and_defaults(py::module &);
-void init_ex_virtual_functions(py::module &);
-void init_ex_keep_alive(py::module &);
-void init_ex_opaque_types(py::module &);
-void init_ex_pickling(py::module &);
-void init_ex_inheritance(py::module &);
-void init_ex_stl_binder_vector(py::module &);
-void init_ex_eval(py::module &);
-void init_ex_custom_exceptions(py::module &);
-void init_ex_numpy_dtypes(py::module &);
-void init_ex_enum(py::module &);
-void init_issues(py::module &);
+std::list<std::function<void(py::module &)>> &initializers() {
+    static std::list<std::function<void(py::module &)>> inits;
+    return inits;
+}
 
-#if defined(PYBIND11_TEST_EIGEN)
-    void init_eigen(py::module &);
-#endif
+test_initializer::test_initializer(std::function<void(py::module &)> initializer) {
+    initializers().push_back(std::move(initializer));
+}
 
 void bind_ConstructorStats(py::module &m) {
     py::class_<ConstructorStats>(m, "ConstructorStats")
@@ -54,35 +36,10 @@ PYBIND11_PLUGIN(pybind11_tests) {
 
     bind_ConstructorStats(m);
 
-    init_ex_methods_and_attributes(m);
-    init_ex_python_types(m);
-    init_ex_operator_overloading(m);
-    init_ex_constants_and_functions(m);
-    init_ex_callbacks(m);
-    init_ex_sequences_and_iterators(m);
-    init_ex_buffers(m);
-    init_ex_smart_ptr(m);
-    init_ex_modules(m);
-    init_ex_numpy_vectorize(m);
-    init_ex_arg_keywords_and_defaults(m);
-    init_ex_virtual_functions(m);
-    init_ex_keep_alive(m);
-    init_ex_opaque_types(m);
-    init_ex_pickling(m);
-    init_ex_inheritance(m);
-    init_ex_stl_binder_vector(m);
-    init_ex_eval(m);
-    init_ex_custom_exceptions(m);
-    init_ex_numpy_dtypes(m);
-    init_ex_enum(m);
-    init_issues(m);
+    for (const auto &initializer : initializers())
+        initializer(m);
 
-#if defined(PYBIND11_TEST_EIGEN)
-    init_eigen(m);
-    m.attr("have_eigen") = py::cast(true);
-#else
-    m.attr("have_eigen") = py::cast(false);
-#endif
+    if (!m.attr("have_eigen")) m.attr("have_eigen") = py::cast(false);
 
     return m.ptr();
 }