Lazy default argument construction

Issue description

Having a non primitive default argument will cause its instantiation when loading the module using python import.
If the default argument's construction takes too long or performs some undesired action there is no way to avoid it (without changing my C++ code).
Is there a way to solve this issue? or work around it?

Reproducible example code

MyLib.dll:

    class SomeClass
    {
    public:
        SomeClass()
        {
            std::cout << "SomeClass" << std::endl;
        }
    };
    class MyClass
    {
    public:
        MyClass(SomeClass s = SomeClass())
        {
            std::cout << "MyClass" << std::endl;
        }
    };

MyLibWrapper.cpp:

    py::class_<SomeClass> SomeClass(m, "SomeClass");
    py::class_<MyClass> MyClass(m, "MyClass");
    MyClass.def(py::init<SomeClass>(), "s"_a = SomeClass());

In python, calling:

import MyLibWrapper

will print:

SomeClass

Start from the py::class_ registration and the MyClass.def(py::init(), "s"_a = SomeClass()) example, then reproduce the behavior with import MyLibWrapper. Determine whether pybind11 provides a lazy default or documented workaround, and verify that importing the module no longer constructs SomeClass unnecessarily.