fix(protocol): use variant ordering instead of Equal for incomparable Value types

The Ord impl for Value was returning Ordering::Equal for cross-type
comparisons (e.g. Date vs unparsable String, or any mismatched types).
This violated the Ord contract since PartialEq correctly returned false
for these pairs. Using Equal when values aren't equal breaks BTreeMaps,
sorting stability, and deduplication.

Now falls back to comparing variant discriminants, which gives a
consistent total order without falsely claiming equality.

https://claude.ai/code/session_01MYGPgMX6xJmjz7g27bsMcD

Author: claude

helix-db/src/protocol/value.rs

@@ -41,6 +41,29 @@ pub enum Value {
 }
 
 impl Value {
+    fn variant_order(&self) -> u8 {
+        match self {
+            Value::String(_) => 0,
+            Value::F32(_) => 1,
+            Value::F64(_) => 2,
+            Value::I8(_) => 3,
+            Value::I16(_) => 4,
+            Value::I32(_) => 5,
+            Value::I64(_) => 6,
+            Value::U8(_) => 7,
+            Value::U16(_) => 8,
+            Value::U32(_) => 9,
+            Value::U64(_) => 10,
+            Value::U128(_) => 11,
+            Value::Date(_) => 12,
+            Value::Boolean(_) => 13,
+            Value::Id(_) => 14,
+            Value::Array(_) => 15,
+            Value::Object(_) => 16,
+            Value::Empty => 17,
+        }
+    }
+
     pub fn inner_stringify(&self) -> String {
         match self {
             Value::String(s) => s.to_string(),
@@ -221,10 +244,10 @@ impl Ord for Value {
                             cmp
                         }
                     }
-                    Err(_) => Ordering::Equal,
+                    Err(_) => self.variant_order().cmp(&other.variant_order()),
                 }
             }
-            (_, _) => Ordering::Equal,
+            (_, _) => self.variant_order().cmp(&other.variant_order()),
         }
     }
 }