Implement a simplified std::vector<T> in C++.

This task requires building a dynamically growing array template that manages raw memory allocation, object construction/destruction, and adheres to C++'s Rule of Five. The implementation should consider element types that are expensive to copy, move-only, or have throwing copy constructors. Key requirements include:

• Core Functionality: Default construction, destruction, copy/move construction and assignment.
• Dynamic Growth: push_back (and ideally emplace_back) with amortized O(1) complexity. The growth factor strategy must be justified.
• Accessors: operator[], size(), capacity(), and reserve().
• Type Safety: Correct handling of element type T, including non-default-constructible types and types with throwing copy constructors.

Constraints & Assumptions:

• Target C++17 or later.
• Allowed headers: <new>, <memory>, <type_traits>, <utility>.
• Prohibited: std::vector or any other STL container for underlying storage.
• T can be any object type; it may be move-only or have a throwing copy constructor.
• push_back must have amortized O(1) complexity.
• Single-threaded use only.
• Global ::operator new / ::operator delete are acceptable for storage. Storage allocation must be separate from element construction.

Key Implementation Areas:

1. Data Layout and Basic Operations: Define the internal structure, implement size(), capacity(), operator[], and the non-reallocating path of push_back. Explain the growth policy and its amortized O(1) justification.
2. Memory Management and Rule of Five: Implement raw storage allocation, element construction/destruction, and the destructor. Implement copy/move constructors and assignment operators.
3. Exception Safety: Ensure push_back provides at least basic exception safety during reallocation. Discuss strong exception safety and when moving elements is preferable to copying.
4. Type Traits Optimization: Utilize C++ type traits to optimize operations like buffer relocation (e.g., memcpy for trivially copyable types) and skipping destructor calls for trivial types.