Implement Memory Safety Patterns

Categorizes six memory-bug types - use-after-free, double-free, memory leak, buffer overflow, dangling pointer, and data race - with their standard prevention technique, and places languages on a safety spectrum from manual memory management in C through smart pointers in C++, ownership in Rust, to garbage collection in Go and Java. Ships six language-specific patterns: RAII in C++ for scope-bound resource cleanup, smart pointers in C++ (unique_ptr and shared_ptr for automatic deallocation), Rust ownership (move semantics that invalidate the original binding, immutable and mutable borrowing rules enforced at compile time, lifetime annotations tracking reference validity such as on a struct holding a borrowed &str, interior mutability via Cell and RefCell for single-threaded mutation through a shared reference, Rc for single-threaded reference-counted shared ownership, and Arc for thread-safe shared ownership demonstrated across spawned threads), safe resource management in C (a goto-cleanup pattern that frees every allocated resource on any early exit path, an opaque-pointer create/destroy pattern hiding a struct's internals behind context_create and context_destroy, and the GCC/Clang cleanup attribute for scope-based auto-free), bounds checking, and preventing data races. Documents four debugging tools by name and purpose: AddressSanitizer (Clang/GCC) for detecting memory errors at runtime, Valgrind for memory leak and error detection, Rust's Miri for detecting undefined behavior, and ThreadSanitizer for detecting data races.

Use it when writing or reviewing memory-management code in C, C++, or Rust, choosing between manual and automatic memory-safety approaches, or debugging a memory error or data race. Skip it for anything unrelated to memory safety or outside this scope.

Input is a memory-management concern - a resource that needs deterministic cleanup, shared ownership across threads, or a suspected memory bug; output is the matching language-specific pattern, such as RAII, a smart pointer, Rust ownership and borrowing, or a C cleanup pattern, plus the sanitizer or tool to verify the fix.

Language-native mechanisms: C++'s RAII and smart pointers, Rust's ownership and borrow checker with Rc and Arc, and C's manual patterns with GCC and Clang's cleanup attribute extension. Debugging via AddressSanitizer, Valgrind, Miri, and ThreadSanitizer.

Systems programmers writing or auditing memory-management code in C, C++, or Rust who need concrete per-language patterns and the matching detection tool rather than an abstract memory-safety overview. Also covers debugging existing memory issues and weighing language choice - C, C++, or Rust - when starting something safety-critical from scratch.