fix(include): snapshot base_dir at load_file_into_program entry

base_dir was aliased to get_base_dir()'s static buffer at the call
site. A nested #INCLUDE "../foo" recursive call recomputed
get_base_dir() inside the recursion, overwriting that buffer — so
when the recursion returned, the parent's view of *its own*
directory was now the included file's directory. The parent's
next #INCLUDE in the same file then resolved against the wrong
base.

Concrete failure: shooter.bas at /shooter/shooter.bas with
  #INCLUDE "../maplib.bas"
  #INCLUDE "level1.bas"
The first include recursed into /shooter/../maplib.bas; on return
shooter.bas's base_dir had been clobbered to "/shooter/..", so
"level1.bas" resolved to "/shooter/../level1.bas" (no such file)
and basic-gfx exit(1)'d with "Cannot open …".

Fix: copy base_dir into a stack-local buffer at function entry and
re-point the parameter at it. Each recursion now has its own
stable base_dir even though get_base_dir's static is shared.

Test added:
  tests/include_chain_test.bas + include_chain/main.bas + inner.bas
  + include_chain_lib.bas — two-include chain that pre-fix exit(1)'d
  on the second include and now returns 18 (7+11).

Author: omiq

basic.c

@@ -15883,6 +15883,16 @@ static void load_file_into_program(const char *path, const char *base_dir, int i
     int number;
     const char *resolved;
     int i;
+    /* Snapshot base_dir into a stack-local buffer. The caller's `base_dir`
+     * may alias get_base_dir's static buffer, which our recursive
+     * #INCLUDE call would overwrite — corrupting the parent's view of
+     * its own directory and breaking the second include in a row. */
+    char base_dir_local[MAX_INCLUDE_PATH];
+    if (base_dir) {
+        strncpy(base_dir_local, base_dir, sizeof(base_dir_local) - 1);
+        base_dir_local[sizeof(base_dir_local) - 1] = '\0';
+        base_dir = base_dir_local;
+    }
 
     if (include_depth >= MAX_INCLUDE_DEPTH) {
         fprintf(stderr, "Include nesting too deep: %s\n", path);

tests/include_chain/inner.bas

@@ -0,0 +1,5 @@
+REM Same-dir include; would resolve incorrectly if the parent's
+REM base_dir had been overwritten by the previous "../" include.
+FUNCTION inner_value()
+  RETURN 11
+END FUNCTION

tests/include_chain/main.bas

@@ -0,0 +1,9 @@
+REM Two includes in a row: first uses "../" (overwrote the
+REM aliased-static base_dir buffer pre-fix), second is a sibling
+REM that pre-fix resolved against the corrupted dir and exit(1)'d.
+#INCLUDE "../include_chain_lib.bas"
+#INCLUDE "inner.bas"
+
+FUNCTION main_value()
+  RETURN inner_value() + lib_value()
+END FUNCTION

tests/include_chain_lib.bas

@@ -0,0 +1,4 @@
+REM Sibling-of-parent lib (one level up from main.bas).
+FUNCTION lib_value()
+  RETURN 7
+END FUNCTION

tests/include_chain_test.bas

@@ -0,0 +1,9 @@
+REM Regression: load_file_into_program's `base_dir` aliased
+REM get_base_dir's static buffer. A nested #INCLUDE "../foo" inside
+REM main.bas overwrote that buffer, so main.bas's *next* include
+REM resolved against the corrupted directory and basic-gfx exit(1)'d
+REM with "Cannot open …". Fixed by snapshotting base_dir into a
+REM stack-local buffer at function entry.
+#INCLUDE "include_chain/main.bas"
+
+PRINT main_value()