refactor: fase 2 — elimina malloc/free a jdraw8 i paletes d'escenes

- JD8_Init/Quit: new[]/delete[] per a screen, main_palette, pixel_data
- JD8_NewSurface/FreeSurface: new Uint8[64000]{}/delete[]
- JD8_LoadPalette: uniforme — sempre retorna `new Color[256]`, copiant del
  LoadPalette extern al path no-cached (l'intermedi raw es frees amb free()
  perquè gif.h el malloca)
- JD8_SetScreenPalette: delete[] la paleta reemplaçada
- slides/secreta/menu/banner/mort scenes: std::free/std::malloc → delete[]/new Color[256]

Ownership uniforme: tot el cicle de vida de surface/palette usa new[]/delete[].

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

source/core/jail/jdraw8.cpp

@@ -24,15 +24,18 @@ JD8_Palette main_palette = nullptr;
 Uint32* pixel_data = nullptr;
 
 void JD8_Init() {
-    screen = static_cast<JD8_Surface>(calloc(1, 64000));
+    screen = new Uint8[64000]{};
-    main_palette = static_cast<JD8_Palette>(calloc(1, 768));
+    main_palette = new Color[256]{};
-    pixel_data = static_cast<Uint32*>(calloc(1, 320 * 200 * 4));
+    pixel_data = new Uint32[320 * 200]{};
 }
 
 void JD8_Quit() {
-    if (screen != nullptr) free(screen);
+    delete[] screen;
-    if (main_palette != nullptr) free(main_palette);
+    delete[] main_palette;
-    if (pixel_data != nullptr) free(pixel_data);
+    delete[] pixel_data;
+    screen = nullptr;
+    main_palette = nullptr;
+    pixel_data = nullptr;
 }
 
 void JD8_ClearScreen(Uint8 color) {
@@ -40,12 +43,7 @@ void JD8_ClearScreen(Uint8 color) {
 }
 
 JD8_Surface JD8_NewSurface() {
-    JD8_Surface surface = static_cast<JD8_Surface>(calloc(1, 64000));
+    return new Uint8[64000]{};
-    if (surface == nullptr) {
-        printf("JD8_NewSurface: out of memory\n");
-        exit(1);
-    }
-    return surface;
 }
 
 // Helper intern: deriva el basename d'una ruta per a buscar al Cache.
@@ -85,31 +83,31 @@ JD8_Surface JD8_LoadSurface(const char* file) {
 }
 
 JD8_Palette JD8_LoadPalette(const char* file) {
+    // Sempre retorna un buffer de 256 colors reservat amb `new Color[256]`
+    // — el caller és responsable d'alliberar-lo amb `delete[]` (o lliurar-ne
+    // l'ownership a `JD8_SetScreenPalette`).
+    JD8_Palette palette = new Color[256];
+
     if (Resource::Cache::get() != nullptr) {
         try {
             const auto& cached = Resource::Cache::get()->getPaletteBytes(jd8_basename(file));
-            // Reservem un buffer 768 bytes (256 * RGB) que el caller ha
-            // d'alliberar amb free() — mateixa convenció que el LoadPalette
-            // original (retornava un malloc).
-            JD8_Palette palette = static_cast<JD8_Palette>(malloc(768));
-            if (palette == nullptr) {
-                printf("JD8_LoadPalette: out of memory\n");
-                exit(1);
-            }
             memcpy(palette, cached.data(), 768);
             return palette;
         } catch (const std::exception&) {
-            // No està al cache.
+            // No està al cache — fallback a lectura + LoadPalette.
         }
     }
 
     auto buffer = ResourceHelper::loadFile(file);
-    return reinterpret_cast<JD8_Palette>(LoadPalette(buffer.data()));
+    Uint8* raw = LoadPalette(buffer.data());  // external malloc
+    memcpy(palette, raw, 768);
+    free(raw);
+    return palette;
 }
 
 void JD8_SetScreenPalette(JD8_Palette palette) {
     if (main_palette == palette) return;
-    if (main_palette != nullptr) free(main_palette);
+    delete[] main_palette;
     main_palette = palette;
 }
 
@@ -225,7 +223,7 @@ Uint32* JD8_GetFramebuffer() {
 }
 
 void JD8_FreeSurface(JD8_Surface surface) {
-    free(surface);
+    delete[] surface;
 }
 
 Uint8 JD8_GetPixel(JD8_Surface surface, int x, int y) {

source/scenes/banner_scene.cpp

@@ -32,7 +32,7 @@ namespace scenes {
         // PaletteFade copia internament amb memcpy; alliberem la paleta temporal.
         JD8_Palette pal = JD8_LoadPalette("gfx/ffase.gif");
         fade_.startFadeTo(pal);
-        std::free(pal);
+        delete[] pal;
 
         phase_ = Phase::FadingIn;
         remaining_ms_ = 5000;

source/scenes/menu_scene.cpp

@@ -21,7 +21,7 @@ namespace scenes {
 
         JD8_Palette pal = JD8_LoadPalette("gfx/menu2.gif");
         fade_.startFadeTo(pal);
-        std::free(pal);
+        delete[] pal;
 
         phase_ = Phase::FadingIn;
     }

source/scenes/mort_scene.cpp

@@ -22,7 +22,7 @@ namespace scenes {
         // la paleta temporal immediatament.
         JD8_Palette pal = JD8_LoadPalette("gfx/gameover.gif");
         fade_.startFadeTo(pal);
-        std::free(pal);
+        delete[] pal;
 
         phase_ = Phase::FadingIn;
         remaining_ms_ = 10000;

source/scenes/secreta_scene.cpp

@@ -37,7 +37,7 @@ namespace {
 namespace scenes {
 
     SecretaScene::~SecretaScene() {
-        if (pal_aux_) std::free(pal_aux_);
+        delete[] pal_aux_;
         // pal_active_ NO s'allibera: propietat de main_palette via SetScreenPalette.
     }
 
@@ -51,7 +51,7 @@ namespace scenes {
 
         gfx_ = SurfaceHandle("gfx/tomba1.gif");
         pal_aux_ = JD8_LoadPalette("gfx/tomba1.gif");
-        pal_active_ = static_cast<JD8_Palette>(std::malloc(768));
+        pal_active_ = new Color[256];
         std::memcpy(pal_active_, pal_aux_, 768);
 
         phase_ = Phase::InitialFadeOut;
@@ -62,7 +62,7 @@ namespace scenes {
         JD8_ClearScreen(255);
         gfx_.reset("gfx/tomba2.gif");
 
-        std::free(pal_aux_);
+        delete[] pal_aux_;
         pal_aux_ = JD8_LoadPalette("gfx/tomba2.gif");
         // pal_active_ continua sent el mateix buffer: només actualitzem
         // el seu contingut. main_palette ja apunta ací.

source/scenes/slides_scene.cpp

@@ -31,7 +31,7 @@ namespace {
 namespace scenes {
 
     SlidesScene::~SlidesScene() {
-        if (pal_aux_) std::free(pal_aux_);
+        delete[] pal_aux_;
         // pal_active_ NO s'allibera: propietat de main_palette via SetScreenPalette.
     }
 
@@ -54,7 +54,7 @@ namespace scenes {
         // main_palette després del SetScreenPalette — modificar-la modifica
         // main_palette directament. `pal_aux_` es manté intacte per a poder
         // restaurar després de cada fade-out intermedi.
-        pal_active_ = static_cast<JD8_Palette>(std::malloc(768));
+        pal_active_ = new Color[256];
         std::memcpy(pal_active_, pal_aux_, 768);
         JD8_SetScreenPalette(pal_active_);