Memory retention: ~6 MB/cycle heap growth when creating/destroying artboards with data binding

#include <rive/file.hpp>
#include <rive/artboard.hpp>
#include <rive/animation/state_machine_instance.hpp>
#include <rive/viewmodel/viewmodel_instance.hpp>
#include "rive_file_reader.hpp"
#include <catch.hpp>
#include <cstdio>
#ifdef __APPLE__
#include <malloc/malloc.h>
#include <mach/mach.h>
#else
#include <malloc.h>
#endif

using namespace rive;

static size_t getHeapUsage()
{
#ifdef __APPLE__
    malloc_statistics_t stats;
    size_t total = 0;
    unsigned int count = 0;
    malloc_zone_t** zones = nullptr;
    kern_return_t err = malloc_get_all_zones(
        mach_task_self(), nullptr, (vm_address_t**)&zones, &count);
    if (err == KERN_SUCCESS)
    {
        for (unsigned int i = 0; i < count; i++)
        {
            malloc_zone_statistics(zones[i], &stats);
            total += stats.size_in_use;
        }
    }
    return total;
#else
    struct mallinfo mi = mallinfo();
    return mi.uordblks;
#endif
}

TEST_CASE("heap growth with data binding", "[data binding]")
{
    auto file = ReadRiveFile("assets/blinko.riv");
    REQUIRE(file != nullptr);

    constexpr int NUM_CYCLES = 10;
    constexpr int FRAMES_PER_CYCLE = 30;

    // Warm up — first cycle allocates caches, font data, etc.
    {
        auto artboard = file->artboardDefault()->instance();
        auto vmi = file->createDefaultViewModelInstance(artboard.get());
        if (vmi)
        {
            auto machine = artboard->defaultStateMachine();
            if (machine)
            {
                machine->bindViewModelInstance(vmi);
                for (int f = 0; f < FRAMES_PER_CYCLE; f++)
                    machine->advanceAndApply(0.016f);
            }
        }
    }

    size_t baselineHeap = getHeapUsage();

    for (int i = 0; i < NUM_CYCLES; i++)
    {
        {
            auto artboard = file->artboardDefault()->instance();
            auto vmi = file->createDefaultViewModelInstance(artboard.get());
            auto machine = artboard->defaultStateMachine();
            machine->bindViewModelInstance(vmi);
            machine->advanceAndApply(0.0f);
            for (int f = 0; f < FRAMES_PER_CYCLE; f++)
                machine->advanceAndApply(0.016f);
            // artboard, machine, vmi all go out of scope here
        }

        size_t heap = getHeapUsage();
        printf("Cycle %2d: growth_from_baseline=%.1f MB\n",
               i, (heap - baselineHeap) / (1024.0 * 1024.0));
    }

    size_t finalHeap = getHeapUsage();
    double totalGrowth = (double)(finalHeap - baselineHeap) / (1024.0 * 1024.0);
    printf("Total growth: %.1f MB (%.2f MB/cycle)\n", totalGrowth, totalGrowth / NUM_CYCLES);

    // After all objects are destroyed, heap should return near baseline
    REQUIRE(totalGrowth < 5.0);  // Currently fails: ~63 MB growth
}