Integrate with C libraries

We have to call an existing C graphics library from our C++ renderer. Add thin, exception-safe wrappers so the renderer can use the API without leaking C semantics. Create header renderer/native_texture.h and implementation files that manage the C handle lifetime, translate error codes into std::error_code, and provide both move and copy semantics only where safe. Update one example in samples/textured_quad.cpp to use the wrappers.

Before I hand the integration to QA, make the wrapper easy to accept. Surface the ownership model at the top of the header, put the error mapping table and common failure modes on the first page, provide a small usage snippet showing correct lifetime and an anti-pattern snippet showing what not to do, and flag any C API behaviors (internally-owned callbacks, thread-affinity) that may surprise reviewers.

I wired the C library's async callback to a C++ method on TextureLoader, and during stress tests the process crashes inside that callback. I suspect the C library calls on a different thread or after our object is destroyed. I cannot change the C API. What is the most likely diagnosis and the safest change to make now so callbacks never access freed C++ state, while keeping throughput reasonable?

Across multiple projects we keep hitting threading and lifetime bugs when integrating C libraries: callbacks invoked on unknown threads, opaque handles that owners drop, and error codes swallowed. I waste cycles adding ad-hoc shims per library. What consistent pattern or small library should I adopt across the team to standardize ownership, thread-safety, and error translation so future integrations are predictable?