Fix: implement trivial destructors for static PyObject unique pointers to avoid invalid memory access on exit

[LinZhihao-723]

Description

The static destructors of the global/static PyObject unique pointers (such as Py types and exceptions) will attempt to decrease the reference count when the process exits. However, its behavior is undefined due to the following reasons, which was first exposed in Python 3.10.12 on Linux with a segfault on exit:

1. the Python interpreter can exit before the global/static destructors execute. Accessing the reference count is illegal if the interpreter is already shut down. There is no way to guarantee the ordering of the execution for the interpreter cleanup and the global/static destructors.
2. C++ RAII guarantees that some code will execute when the scope exits, but it doesn't guarantee that all of the code finishes executing; the process may exit before the RAII destructor is complete.

This PR fixes the problem by making all the global/static Pyobject pointers trivially destructible. This means it will not attempt to release any resources when reset or destruction happens, which can lead to potential memory leaks. However, according to the current use case, this is acceptable since the only expected execution of the trivial destructor is on process exit.

We keep using smart ptr for two purposes:

1. protect the underlying raw pointers from being exposed and accidentally modified.
2. indicate the underlying object will never be freed by C++ static destructor.