refactor(undo): de-Qt oakundo and wrap it in a pure C ABI

- strip QAbstractItemModel/QAction/signals-slots from UndoStack (UI
  concerns belong to the app layer), index_changed becomes a
  std::function callback
- decouple UndoCommand from Project via an optional modified-flag
  callback pair
- add pure C ABI in include/undo + src/undo/c_api (oakundo_ prefix,
  vtable-based command wrapper, OAKUNDO_E_* error codes)
- fix three engine-side defects: jump(0) infinite loop,
  MultiUndoCommand child leak, push_pre_executed not undoable
- add gtest suites (22 cases) and a standalone build driver

include/undo/undostack.h

@@ -0,0 +1,164 @@
+/***
+
+  Oak Video Editor - Non-Linear Video Editor
+  Copyright (C) 2026 Oak Team
+
+  This program is free software: you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation, either version 3 of the License, or
+  (at your option) any later version.
+
+  This program is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+***/
+
+#ifndef OAK_EDITOR_UNDO_UNDOSTACK_H
+#define OAK_EDITOR_UNDO_UNDOSTACK_H
+
+#include <stdint.h>
+
+#include "undo/error.h"
+#include "undo/undocommand.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * @brief Opaque handle to an undo stack (olive::UndoStack).
+ */
+typedef struct OakUndoStack OakUndoStack;
+
+/**
+ * @brief Create an undo stack.
+ *
+ * A fresh stack contains a single "New/Open Project" empty command,
+ * matching olive::UndoStack::clear().
+ *
+ * @return Stack handle, or NULL on allocation failure.
+ */
+OakUndoStack *oakundo_undostack_init(void);
+
+/**
+ * @brief Destroy an undo stack and all commands it owns.
+ *
+ * NULL is a no-op.
+ */
+void oakundo_undostack_free(OakUndoStack *stack);
+
+/**
+ * @brief Push `command` onto the stack and execute its redo.
+ *
+ * On success the stack takes ownership of the underlying command; the
+ * handle wrapper is consumed and must not be used or freed afterwards.
+ * An empty multi command is deleted immediately (not pushed), matching
+ * olive::UndoStack::push. `name` is the user-visible label (NULL behaves
+ * like an empty label).
+ *
+ * @return OAKUNDO_OK or a negative OAKUNDO_E_* error code.
+ */
+int oakundo_undostack_push(OakUndoStack *stack, OakUndoCommand *command,
+						   const char *name);
+
+/**
+ * @brief Push a command that has already been executed (redo skipped).
+ *
+ * Ownership rules match oakundo_undostack_push().
+ *
+ * @return OAKUNDO_OK or a negative OAKUNDO_E_* error code.
+ */
+int oakundo_undostack_push_pre_executed(OakUndoStack *stack,
+										OakUndoCommand *command,
+										const char *name);
+
+/**
+ * @brief Undo the most recently done command, if any.
+ *
+ * @return OAKUNDO_OK or a negative OAKUNDO_E_* error code.
+ */
+int oakundo_undostack_undo(OakUndoStack *stack);
+
+/**
+ * @brief Redo the most recently undone command, if any.
+ *
+ * @return OAKUNDO_OK or a negative OAKUNDO_E_* error code.
+ */
+int oakundo_undostack_redo(OakUndoStack *stack);
+
+/**
+ * @brief Undo/redo until the done-command count equals `index`
+ * (olive::UndoStack::jump semantics). Negative values are clamped to 0.
+ *
+ * @return OAKUNDO_OK or a negative OAKUNDO_E_* error code.
+ */
+int oakundo_undostack_jump(OakUndoStack *stack, int64_t index);
+
+/**
+ * @brief Delete all commands and push the fresh "New/Open Project" empty
+ * command (olive::UndoStack::clear).
+ *
+ * @return OAKUNDO_OK or a negative OAKUNDO_E_* error code.
+ */
+int oakundo_undostack_clear(OakUndoStack *stack);
+
+/**
+ * @brief Query whether undo (redo) is currently possible.
+ *
+ * @param out_value Receives 1/0. Must not be NULL.
+ *
+ * @return OAKUNDO_OK or a negative OAKUNDO_E_* error code.
+ */
+int oakundo_undostack_can_undo(OakUndoStack *stack, int *out_value);
+int oakundo_undostack_can_redo(OakUndoStack *stack, int *out_value);
+
+/**
+ * @brief Total number of history rows (done + undone commands).
+ *
+ * @param out_count Receives the result. Must not be NULL.
+ *
+ * @return OAKUNDO_OK or a negative OAKUNDO_E_* error code.
+ */
+int oakundo_undostack_count(OakUndoStack *stack, int64_t *out_count);
+
+/**
+ * @brief Current position in the history: the number of done commands
+ * (rows at or above this index are undone).
+ *
+ * @param out_index Receives the result. Must not be NULL.
+ *
+ * @return OAKUNDO_OK or a negative OAKUNDO_E_* error code.
+ */
+int oakundo_undostack_index(OakUndoStack *stack, int64_t *out_index);
+
+/**
+ * @brief Label of the history row at `row` (0-based, two-stage getter).
+ *
+ * @return Required buffer size in bytes including the terminating NUL
+ *         (non-negative), OAKUNDO_E_NOT_FOUND for an invalid row, or
+ *         another negative OAKUNDO_E_* error code.
+ */
+int oakundo_undostack_command_text(OakUndoStack *stack, int64_t row,
+								   char *buf, int buf_size);
+
+/**
+ * @brief Query whether the row at `row` is currently done (not undone).
+ *
+ * @param out_value Receives 1 (done) / 0 (undone). Must not be NULL.
+ *
+ * @return OAKUNDO_OK, OAKUNDO_E_NOT_FOUND for an invalid row, or another
+ *         negative OAKUNDO_E_* error code.
+ */
+int oakundo_undostack_command_is_done(OakUndoStack *stack, int64_t row,
+									  int *out_value);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif //OAK_EDITOR_UNDO_UNDOSTACK_H