internal: new shared_ptr and weak_ptr implementation (#5883)

moves std::shared_ptrs to a new implementation

Advantages:
- you can dereference a weak_ptr directly. This will obviously segfault on a nullptr deref if it's expired.
   - this is useful to avoid the .lock() hell where we are 100% sure the pointer _should_ be valid. (and if it isn't, it should throw.)
- weak_ptrs are still valid while the SP is being destroyed.
   - reasoning: while an object (e.g. CWindow) is being destroyed, its `weak_ptr self` should be accessible (the sp is still alive, and so is CWindow), but it's not because by stl it's already expired (to prevent resurrection)
   - this impl solves it differently. w_p is expired, but can still be dereferenced and used. Creating `s_p`s is not possible anymore, though.
   - this is useful in destructors and callbacks.

src/helpers/signal/Listener.hpp

@@ -3,6 +3,7 @@
 #include <any>
 #include <memory>
 #include <functional>
+#include "../../macros.hpp"
 
 class CSignal;
 
@@ -21,7 +22,7 @@ class CSignalListener {
     std::function<void(std::any)> m_fHandler;
 };
 
-typedef std::shared_ptr<CSignalListener> CHyprSignalListener;
+typedef SP<CSignalListener> CHyprSignalListener;
 
 class CStaticSignalListener {
   public:

src/helpers/signal/Signal.cpp

@@ -20,8 +20,8 @@ void CSignal::emit(std::any data) {
 }
 
 CHyprSignalListener CSignal::registerListener(std::function<void(std::any)> handler) {
-    CHyprSignalListener listener = std::make_shared<CSignalListener>(handler);
-    m_vListeners.emplace_back(std::weak_ptr<CSignalListener>(listener));
+    CHyprSignalListener listener = makeShared<CSignalListener>(handler);
+    m_vListeners.emplace_back(WP<CSignalListener>(listener));
     return listener;
 }
 

src/helpers/signal/Signal.hpp

@@ -19,6 +19,6 @@ class CSignal {
     void registerStaticListener(std::function<void(void*, std::any)> handler, void* owner);
 
   private:
-    std::vector<std::weak_ptr<CSignalListener>>         m_vListeners;
+    std::vector<WP<CSignalListener>>                    m_vListeners;
     std::vector<std::unique_ptr<CStaticSignalListener>> m_vStaticListeners;
 };