fix: Normalize relative paths to canonical form for CMake compatibility

CMake and some build tools prefer canonical relative paths like
'../dir/file' over equivalent but non-canonical forms like 'dir/../file'.

The pathdiff crate can generate non-canonical paths when calculating
relative paths between directories. This commit adds lexical path
normalization by processing path components: when we encounter a
ParentDir (..) component, we pop the previous component instead of
keeping both.

Example transformation:
- Before: cpp/../generated/file.cpp
- After: ../cpp/generated/file.cpp

This ensures better compatibility with CMake and other build tools
that may not handle non-canonical paths correctly.

Discovered while testing the RustBuffer 32-bit ARM fix on Android.

Author: sfourdrinier

crates/ubrn_cli/src/codegen/mod.rs

@@ -26,7 +26,36 @@ pub(crate) trait RenderedFile: DynTemplate {
         let from = file
             .parent()
             .expect("Expected this file to have a directory");
-        pathdiff::diff_utf8_paths(to, from).expect("Should be able to find a relative path")
+        let path = pathdiff::diff_utf8_paths(to, from).expect("Should be able to find a relative path");
+
+        // Normalize paths for better compatibility with tools like CMake.
+        // pathdiff can generate "dir/.." patterns which, while technically correct,
+        // are not canonical. Normalize by resolving against a dummy base and taking the relative path.
+        // Example: "cpp/../generated/file.cpp" becomes "../cpp/generated/file.cpp"
+        use camino::Utf8Component;
+        let mut normalized = Utf8PathBuf::new();
+
+        for component in path.components() {
+            match component {
+                Utf8Component::Normal(name) => {
+                    normalized.push(name);
+                }
+                Utf8Component::ParentDir => {
+                    if !normalized.pop() {
+                        // If we can't pop, we need to keep the ..
+                        normalized.push("..");
+                    }
+                }
+                comp => normalized.push(comp),
+            }
+        }
+
+        // If normalized is empty, it means we're in the same directory
+        if normalized.as_str().is_empty() {
+            normalized.push(".");
+        }
+
+        normalized
     }
     fn filter_by(&self) -> bool {
         true