fix(ZBytes): publish the lazy byte cache safely (#517)

The lazy materialization in ZBytes is double-checked locking: the fast path
reads `eager` outside the monitor while the slow path writes it under it.
Without volatile, a reader observing the non-null reference has no
happens-before edge to the copy that filled the array.

Mark `eager` volatile. It moves out of the primary constructor because
@volatile targets fields. The synchronized slow path stays: it is what
guarantees exactly one thread copies out of and closes the native handle.
`handle` stays non-volatile — it is only touched inside the monitor.

Closes #516

Author: milyin

zenoh-java/src/commonMain/kotlin/io/zenoh/bytes/ZBytes.kt

@@ -48,10 +48,19 @@ import io.zenoh.jni.bytes.ZBytes as JniZBytes
  * dropped samples are the one place native memory can be retained.
  */
 class ZBytes private constructor(
-    private var eager: ByteArray?,
+    initialBytes: ByteArray?,
     private var handle: JniZBytes?,
 ) : IntoZBytes {
 
+    /**
+     * The materialized bytes, `null` until a handle-backed ZBytes is read.
+     * Volatile: the [bytes] getter reads it outside the monitor, so the write
+     * under the monitor must be safely published to that unlocked fast path.
+     * `handle` needs no such treatment — it is only touched inside the monitor.
+     */
+    @Volatile
+    private var eager: ByteArray? = initialBytes
+
     internal constructor(bytes: ByteArray) : this(bytes, null)
 
     /**