Enhance performance profiling and tile caching mechanisms

- Introduced a new PerformanceProfiler class for detailed timing and performance measurement across graphics operations.
- Implemented a smart tile cache with LRU eviction in the TileCache structure to optimize memory usage and improve tile rendering efficiency.
- Updated various graphics components to utilize the new caching system, reducing redundant texture updates and enhancing overall performance.
- Added dirty region tracking in Bitmap for efficient texture updates, minimizing the area that needs to be refreshed during rendering.
- Enhanced existing methods to leverage performance monitoring, providing insights into operation durations and potential bottlenecks.

src/app/gfx/tilemap.h

@@ -5,6 +5,9 @@
 #include "app/gfx/bitmap.h"
 #include "app/gfx/snes_tile.h"
 
+#include <list>
+#include <unordered_map>
+
 namespace yaze {
 namespace gfx {
 
@@ -16,6 +19,68 @@ struct Pair {
   int y;  ///< Y coordinate or height
 };
 
+/**
+ * @brief Smart tile cache with LRU eviction for efficient memory management
+ * 
+ * Performance Optimizations:
+ * - LRU eviction policy to keep frequently used tiles in memory
+ * - Configurable cache size to balance memory usage and performance
+ * - O(1) tile access and insertion
+ * - Automatic cache management with minimal overhead
+ */
+struct TileCache {
+  static constexpr size_t MAX_CACHE_SIZE = 1024;
+  std::unordered_map<int, Bitmap> cache_;
+  std::list<int> access_order_;
+  
+  /**
+   * @brief Get a cached tile by ID
+   * @param tile_id Tile identifier
+   * @return Pointer to cached tile bitmap or nullptr if not cached
+   */
+  Bitmap* GetTile(int tile_id) {
+    auto it = cache_.find(tile_id);
+    if (it != cache_.end()) {
+      // Move to front of access order (most recently used)
+      access_order_.remove(tile_id);
+      access_order_.push_front(tile_id);
+      return &it->second;
+    }
+    return nullptr;
+  }
+  
+  /**
+   * @brief Cache a tile bitmap
+   * @param tile_id Tile identifier
+   * @param bitmap Tile bitmap to cache
+   */
+  void CacheTile(int tile_id, Bitmap&& bitmap) {
+    if (cache_.size() >= MAX_CACHE_SIZE) {
+      // Remove least recently used tile
+      int lru_tile = access_order_.back();
+      access_order_.pop_back();
+      cache_.erase(lru_tile);
+    }
+    
+    cache_[tile_id] = std::move(bitmap);
+    access_order_.push_front(tile_id);
+  }
+  
+  /**
+   * @brief Clear the cache
+   */
+  void Clear() {
+    cache_.clear();
+    access_order_.clear();
+  }
+  
+  /**
+   * @brief Get cache statistics
+   * @return Number of cached tiles
+   */
+  size_t Size() const { return cache_.size(); }
+};
+
 /**
  * @brief Tilemap structure for SNES tile-based graphics management
  * 
@@ -23,14 +88,14 @@ struct Pair {
  * 
  * Key Features:
  * - Atlas bitmap containing all tiles in a single texture
- * - Individual tile bitmap cache for fast access
+ * - Smart tile cache with LRU eviction for optimal memory usage
  * - Tile metadata storage (mirroring, palette, etc.)
  * - Support for both 8x8 and 16x16 tile sizes
  * - Efficient tile lookup and rendering
  * 
  * Performance Optimizations:
  * - Hash map storage for O(1) tile access
- * - Lazy tile bitmap creation (only when needed)
+ * - LRU tile caching to minimize memory usage
  * - Atlas-based rendering to minimize draw calls
  * - Tile metadata caching for fast property access
  * 
@@ -42,7 +107,7 @@ struct Pair {
  */
 struct Tilemap {
   Bitmap atlas;                                    ///< Master bitmap containing all tiles
-  absl::flat_hash_map<int, Bitmap> tile_bitmaps;  ///< Individual tile cache
+  TileCache tile_cache;                            ///< Smart tile cache with LRU eviction
   std::vector<std::array<gfx::TileInfo, 4>> tile_info;  ///< Tile metadata (4 tiles per 16x16)
   Pair tile_size;                                  ///< Size of individual tiles (8x8 or 16x16)
   Pair map_size;                                   ///< Size of tilemap in tiles