Add comprehensive interview guide covering C++, Python, and Architecture topics

[Copilot]

This PR adds a comprehensive interview guide (/interview.md) to help developers prepare for technical interviews covering C++, Python, and software architecture topics.

What's Included

The guide provides in-depth coverage of:

C++ Core Topics

• Memory Management: RAII principles, smart pointers (unique_ptr, shared_ptr), memory leak prevention
• STL: Containers, algorithms, iterators with time complexity analysis
• Modern C++ Features: C++11/14/17/20 features including auto, lambdas, move semantics, structured bindings, concepts
• Threading: Multithreading basics, synchronization primitives, atomic operations, futures, thread pool patterns
• Design Patterns: Thread-safe Singleton, Factory, Observer patterns with modern C++ implementations

Python Core Topics

• GIL (Global Interpreter Lock): Understanding its impact and workarounds using multiprocessing/asyncio
• Decorators: Basic, parameterized, and class-based decorators with real-world examples
• Async Programming: async/await syntax, event loops, producer-consumer patterns, async context managers
• Memory Management: Reference counting, garbage collection, optimization techniques using __slots__, generators
• Design Patterns: Pythonic implementations of common patterns

Architecture Topics

• System Design: Load balancing strategies, caching patterns, database sharding with code examples
• Microservices: Service discovery, API gateway, circuit breaker pattern, event sourcing
• Scalability: Horizontal/vertical scaling, performance optimization techniques
• Performance: Optimization strategies for both C++ and Python, profiling, memory efficiency
• Security: Authentication/authorization, encryption, rate limiting, input validation, secure session management

Features

Each topic includes:

• Practical Code Examples: Real, runnable code demonstrating concepts
• Common Interview Questions: With detailed explanations and solutions
• Performance Considerations: Time/space complexity analysis and optimization techniques
• Best Practices: Industry-standard approaches and patterns
• Trade-off Discussions: Pros and cons of different implementation approaches

The guide serves as both a study resource for technical interviews and a reference for day-to-day development work. All examples are production-ready and follow modern best practices.

Example of the depth provided:

// Smart pointer usage with custom deleters
auto custom_deleter = [](FILE* f) { 
    if (f) fclose(f); 
};
std::unique_ptr<FILE, decltype(custom_deleter)> file_ptr(
    fopen("data.txt", "r"), custom_deleter
);

# Thread-safe singleton with proper initialization
class ThreadSafeSingleton:
    _instance = None
    _lock = threading.Lock()
    
    def __new__(cls):
        if cls._instance is None:
            with cls._lock:
                if cls._instance is None:
                    cls._instance = super().__new__(cls)
        return cls._instance

This comprehensive resource aligns with the repository's goal of helping developers master advanced programming skills and system architecture design.

---

💡 You can make Copilot smarter by setting up custom instructions, customizing its development environment and configuring Model Context Protocol (MCP) servers. Learn more Copilot coding agent tips in the docs.