refactor(node,render): route oaknode->oakrender calls through the C ABI

- oakrender cache C API: add create_for_node (four cache kinds),
  get_uuid, request, load/save_state, set_saving_enabled,
  set_passthrough, get_passthroughs, get_valid_cache_filename,
  get_timebase, lock/unlock, invalidate_range (rational variant),
  get_native (C++ only, for the in-module PreviewAutoCacher)
- Node's four caches become owned OakRenderCache value handles; all
  cache access in node.cpp/clip/viewer/traverser/serializers goes
  through the C ABI
- oaknode_node_get_video_frame_cache returns an addref'd
  OakRenderCache; drop OakNodeFrameCache; oaktask precache/export and
  oakrender_video_ticket_params take the value handle
- color: OCIOBaseNode/OCIOLutNode hold OakColorProcessor handles
  (dtors added); oakrender gains color_processor_create_transform/
  create_lut/create_grading_primary/get_native and LUT library
  queries, keeping all OCIO transform construction inside oakrender;
  oaknode gains colormanager_wrap_borrowed/get_native
- RenderManager::instance() check -> oakrender_manager_available();
  cancel_video_tasks and disk cache path go through manager C API
- remaining node->render C++ symbol: only olive::Texture::~Texture
  via Variant's shared_ptr payload (recorded exception, same class as
  the UndoCommand inheritance)

Tests: new cache/color/manager/colormanager cases; all standalone
trees green (common 196, codec 22, audio 40, task 112, render 63,
timeline 125, node 98, plugin 102).

include/render/color.h

@@ -23,6 +23,8 @@
 
 #include "error.h"
 #include "renderer.h"
+#include "common/colortransform.h" /* OakColorTransform */
+#include "node/colormanager.h" /* OakNodeColorManager */
 
 #ifdef __cplusplus
 extern "C" {
@@ -94,6 +96,75 @@ void oakrender_color_processor_free(OakColorProcessor *processor);
  */
 int oakrender_color_processor_is_valid(OakColorProcessor processor);
 
+/**
+ * @brief Create a processor from an input colorspace and a destination
+ *        transform on a node's color manager
+ *        (ColorProcessor::create(ColorManager*, input, dest, dir)).
+ *
+ * @param manager Borrowed manager handle (e.g.
+ *        oaknode_colormanager_wrap_borrowed()).
+ * @param direction OAKRENDER_COLOR_DIRECTION_NORMAL / _INVERSE.
+ * @return Processor handle with reference count 1; ctx is NULL for
+ *         empty/invalid arguments or allocation failure.
+ */
+OakColorProcessor oakrender_color_processor_create_transform(
+	OakNodeColorManager manager, const char *input,
+	OakColorTransform dest, int direction);
+
+/**
+ * @brief Create a processor from a LUT file on a node's color manager
+ *        (OCIO FileTransform with linear interpolation; direction
+ *        selects forward/inverse).
+ *
+ * @return Processor handle with reference count 1; ctx is NULL for
+ *         empty/invalid arguments, an unreadable LUT, or allocation
+ *         failure.
+ */
+OakColorProcessor oakrender_color_processor_create_lut(
+	OakNodeColorManager manager, const char *path, int direction);
+
+/**
+ * @brief Grading-primary transform styles for
+ *        oakrender_color_processor_create_grading_primary().
+ */
+enum OakRenderGradingPrimaryStyle {
+	OAKRENDER_GRADING_PRIMARY_LIN = 0, /**< OCIO GRADING_LIN */
+	OAKRENDER_GRADING_PRIMARY_LOG = 1 /**< OCIO GRADING_LOG */
+};
+
+/**
+ * @brief Create a dynamic grading-primary processor on a node's color
+ *        manager (OCIO GradingPrimaryTransform, forward direction).
+ *
+ * @return Processor handle with reference count 1; ctx is NULL for
+ *         invalid arguments or allocation failure.
+ */
+OakColorProcessor oakrender_color_processor_create_grading_primary(
+	OakNodeColorManager manager, int style);
+
+/* ---- LUT library ---------------------------------------------------- */
+
+/**
+ * @brief 1 when `extension` (without dot, case-insensitive) is a
+ *        supported LUT extension (LUTLibrary::is_supported_extension()).
+ */
+int oakrender_lut_is_supported_extension(const char *extension);
+
+/**
+ * @brief Number of supported LUT extensions
+ *        (LUTLibrary::supported_extensions()).
+ */
+int oakrender_lut_supported_extensions_count(void);
+
+/**
+ * @brief Supported LUT extension at `index`, two-stage string.
+ *
+ * @return Required buffer size in bytes (including NUL), or a negative
+ *         OAKRENDER_E_* code for an out-of-range index.
+ */
+int oakrender_lut_supported_extension_at(int index, char *buf,
+										 int buf_size);
+
 /**
  * @brief Convert a single RGBA color (ColorProcessor::convert_color()).
  * On an invalid processor the input is copied through.
@@ -160,6 +231,23 @@ int oakrender_color_manager_display_transform(const char *display,
 											  const char *view, char *buf,
 											  int n);
 
+#ifdef __cplusplus
+} /* extern "C" */
+
+#include <memory>
+namespace olive { class ColorProcessor; }
+
+extern "C" {
+#endif
+
+/**
+ * @brief Borrowed access to the underlying C++ processor (C++ only, for
+ *        adapter layers; a shared_ptr copy keeps the object alive).
+ *        Empty shared_ptr for an empty handle.
+ */
+std::shared_ptr<olive::ColorProcessor> oakrender_color_processor_get_native(
+	OakColorProcessor processor);
+
 #ifdef __cplusplus
 }
 #endif