fix(object-array): wire VX_TYPE_USER_DATA_OBJECT into exemplar dispatch

The Khronos CTS `UserDataObject.UserKernelObjectArray/*` subtests
(test_user_data_object.c:516) call `vxCreateObjectArray(ctx, udo, 20)`
with a UDO as the exemplar. rustVX's `create_object_like_exemplar`
helper in openvx-core had `match` arms for IMAGE, ARRAY, PYRAMID,
SCALAR, MATRIX, DISTRIBUTION, REMAP, LUT, THRESHOLD, OBJECT_ARRAY —
but not USER_DATA_OBJECT — so the new UDO type tag (0x816) fell to
the `_ => null_mut()` default. `vxCreateObjectArray` then returned
NULL and the CTS `ASSERT_VX_OBJECT(VX_TYPE_OBJECT_ARRAY)` blew up
before the test even got to exercising the UDO API.

Add the missing arm: query `VX_USER_DATA_OBJECT_NAME` /
`VX_USER_DATA_OBJECT_SIZE` from the exemplar, then call
`vxCreateUserDataObject` to produce each fresh slot. Same semantics
as the IMAGE/ARRAY arms — clone the exemplar's metadata, not its
contents, so each slot in the resulting object-array gets its own
independent zero-initialised buffer.

The FFI calls are declared inline because openvx-core can't import
the `vx_user_data_object` alias from openvx-buffer without a
circular dep; `*mut c_void` is the underlying repr (same as the
alias in user_data_object.rs).

The constants `VX_TYPE_USER_DATA_OBJECT` / `VX_USER_DATA_OBJECT_NAME`
/ `VX_USER_DATA_OBJECT_SIZE` / `VX_MAX_REFERENCE_NAME` are declared
as function-local consts to keep the match arm self-documenting
without colliding with the pre-existing file-scope
`VX_TYPE_TARGET = 0x816` (a latent labeling artefact predating this
PR — left untouched here to avoid scope creep).

Verified locally:
* `cargo build --release -p openvx-ffi`   — clean build
* `cargo test  --release -p openvx-ffi --test user_data_object`
  — all 15 existing UDO Rust integration tests still pass

The two failing CTS subtests
(`UserKernelObjectArray/{0,1}/USER_DATA_OBJECT_FROM_{REF,ATTR}`)
should now pass on the next CI run, alongside the 12 UDO subtests
that were already green on the previous run.

Co-authored-by: Cursor <cursoragent@cursor.com>

Author: kiritigowda

openvx-core/src/unified_c_api.rs

@@ -7468,7 +7468,32 @@ fn create_object_like_exemplar(
             thresh_type: vx_enum,
             data_type: vx_enum,
         ) -> vx_threshold;
-    }
+        // vx_user_data_object is `*mut c_void` (see
+        // openvx-buffer/src/user_data_object.rs); openvx-core can't import
+        // the alias without a circular dep, so the raw pointer type is
+        // used inline here.
+        fn vxQueryUserDataObject(
+            udo: *mut c_void,
+            attr: vx_enum,
+            ptr: *mut c_void,
+            size: usize,
+        ) -> vx_status;
+        fn vxCreateUserDataObject(
+            ctx: vx_context,
+            type_name: *const vx_char,
+            size: vx_size,
+            ptr: *const c_void,
+        ) -> *mut c_void;
+    }
+    // VX_TYPE_USER_DATA_OBJECT = 0x816 per vx_khr_user_data_object.h. The
+    // pre-existing file-scope `VX_TYPE_TARGET` constant happens to also
+    // equal 0x816 (a latent labeling artefact predating this code) — a
+    // local shadow keeps this match arm self-documenting without changing
+    // unrelated callers of the old name.
+    const VX_TYPE_USER_DATA_OBJECT: vx_enum = 0x816;
+    const VX_USER_DATA_OBJECT_NAME: vx_enum = 0x0008_1600;
+    const VX_USER_DATA_OBJECT_SIZE: vx_enum = 0x0008_1601;
+    const VX_MAX_REFERENCE_NAME: usize = 64;
     unsafe {
         match exemplar_type {
             VX_TYPE_IMAGE => {
@@ -7703,6 +7728,34 @@ fn create_object_like_exemplar(
                 vxReleaseReference(&mut item_ref as *mut vx_reference);
                 new_array as vx_reference
             }
+            VX_TYPE_USER_DATA_OBJECT => {
+                // Clone the exemplar's metadata (name + byte size) into a
+                // fresh, zero-initialised UDO. `vxCreateObjectArray`
+                // contract is "build `count` independent items shaped like
+                // the exemplar", not "share storage" — so each slot gets
+                // its own backing buffer, matching how the IMAGE/ARRAY
+                // arms above also produce fresh blanks.
+                let mut name = [0u8; VX_MAX_REFERENCE_NAME];
+                let mut size: vx_size = 0;
+                vxQueryUserDataObject(
+                    exemplar as *mut c_void,
+                    VX_USER_DATA_OBJECT_NAME,
+                    name.as_mut_ptr() as *mut c_void,
+                    VX_MAX_REFERENCE_NAME,
+                );
+                vxQueryUserDataObject(
+                    exemplar as *mut c_void,
+                    VX_USER_DATA_OBJECT_SIZE,
+                    &mut size as *mut _ as *mut c_void,
+                    std::mem::size_of::<vx_size>(),
+                );
+                vxCreateUserDataObject(
+                    context,
+                    name.as_ptr() as *const vx_char,
+                    size,
+                    std::ptr::null(),
+                ) as vx_reference
+            }
             _ => std::ptr::null_mut(),
         }
     }