Update guided tour

Signed-off-by: Maksym Pavlenko <pavlenko.maksym@gmail.com>

Author: mxpv

README.md

@@ -25,6 +25,7 @@ These tools make it easy to compile, analyze, and embed `Luau` scripts directly
 - Bidirectional [function calls](#function-calls) between Zig and Lua
 - First-class [userdata support](#userdata-integration) including metamethods
 - Native support for refs, functions, tables, and vector types
+- [Fine-grained garbage collection control](#garbage-collection) for memory management
 - Supports Luau code generation for improved performance on supported platforms
 - Built-in [Luau tools](#-using-luau-tools) (`luau-compile` and `luau-analyze`) provided by the build system
 - Excellent [test coverage](https://app.codecov.io/gh/mxpv/luaz) and API [documentation](https://mxpv.github.io/luaz/#luaz.lua)
@@ -210,6 +211,7 @@ pub fn main() !void {
 }
 ```
 
+
 > [!WARNING]
 > This library is still evolving and the API is not stable. Backward incompatible changes may be introduced up until the 1.0 release. Consider pinning to a specific commit or tag if you need stability.
 
@@ -220,7 +222,6 @@ The following features are planned after the initial release:
 - Luau sandbox APIs - Safe execution environments for untrusted code
 - Coroutine / threads support - Full Luau coroutine and threading capabilities
 - Debug APIs - Debugging hooks and introspection tools
-- GC API - Fine-grained garbage collection control
 - Optional JSON support - Built-in JSON serialization/deserialization
 
 ## 🛠️ Using Luau Tools

examples/guided_tour.zig

@@ -12,6 +12,7 @@
 //! - Use Luau's codegen feature
 //! - Push and retrieve arrays
 //! - Work with tuples and table-based structures
+//! - Control garbage collection for memory management
 
 const std = @import("std");
 const luaz = @import("luaz");
@@ -472,6 +473,82 @@ pub fn main() !void {
         print("Retrieved point coordinates: x={d:.1}, y={d:.1}\n", .{ x_coord.?, y_coord.? });
     }
 
+    // Garbage collection control
+    {
+        print("\n-- Garbage Collection --\n", .{});
+
+        const gc = lua.gc();
+
+        // Monitor memory usage
+        const initial_memory_kb = gc.count();
+        const initial_memory_bytes = gc.countBytes();
+        const initial_total = initial_memory_kb * 1024 + initial_memory_bytes;
+        print("Initial memory usage: {} bytes ({} KB + {} bytes)\n", .{ initial_total, initial_memory_kb, initial_memory_bytes });
+
+        // Create some objects to increase memory usage
+        try lua.eval(
+            \\local large_table = {}
+            \\for i = 1, 1000 do
+            \\    large_table[i] = "String number " .. i .. " with some extra data to use more memory"
+            \\end
+            \\global_table = large_table  -- Keep reference to prevent immediate collection
+        , .{}, void);
+
+        const after_alloc_memory = gc.count();
+        print("Memory after allocation: {} KB (increased by {} KB)\n", .{ after_alloc_memory, after_alloc_memory - initial_memory_kb });
+
+        // Force garbage collection
+        print("Running full garbage collection...\n", .{});
+        gc.collect();
+        const after_gc_memory = gc.count();
+        print("Memory after GC: {} KB\n", .{after_gc_memory});
+
+        // Fine-tune GC parameters
+        print("Adjusting GC parameters...\n", .{});
+        const old_goal = gc.setGoal(150); // Start GC at 50% memory increase
+        const old_stepmul = gc.setStepMul(300); // More aggressive GC
+        const old_stepsize = gc.setStepSize(2048); // Larger GC steps
+        print("Previous GC settings - Goal: {}, StepMul: {}, StepSize: {}\n", .{ old_goal, old_stepmul, old_stepsize });
+
+        // Demonstrate manual GC control
+        print("Stopping GC for manual control...\n", .{});
+        gc.stop();
+        print("GC running: {}\n", .{gc.isRunning()});
+
+        // Create more garbage while GC is stopped
+        try lua.eval("global_table = nil", .{}, void); // Release reference
+        try lua.eval(
+            \\for i = 1, 100 do
+            \\    local temp = {}
+            \\    for j = 1, 50 do
+            \\        temp[j] = "Temporary string " .. i .. "," .. j
+            \\    end
+            \\end
+        , .{}, void);
+
+        // Perform stepped collection
+        print("Performing manual GC steps...\n", .{});
+        var steps: u32 = 0;
+        while (!gc.step(200) and steps < 5) {
+            steps += 1;
+            print("GC step {} completed\n", .{steps});
+        }
+        print("GC cycle completed in {} steps\n", .{steps});
+
+        // Restart normal GC
+        gc.restart();
+        print("GC restarted, running: {}\n", .{gc.isRunning()});
+
+        // Restore original GC parameters
+        _ = gc.setGoal(old_goal);
+        _ = gc.setStepMul(old_stepmul);
+        _ = gc.setStepSize(old_stepsize);
+        print("GC parameters restored\n", .{});
+
+        const final_memory = gc.count();
+        print("Final memory usage: {} KB\n", .{final_memory});
+    }
+
     // Error handling
     {
         print("\n-- Error Handling --\n", .{});