fix!(gix-object): Allow round-tripping for Trees

Change the internal representation of `EntryMode` to fix a round-trip
issue.

Prior to this change, both `b"040000"` and `b"40000"` mapped to
`0o40000u16`.

After this change,
* `b"040000"` is represented by `0o140000`
* `b"40000"` is represented by `0o40000`

*Tests*:

We can see in the `as_bytes` test that the behaviour is fixed now.
We also add a test to show we now can round-trip on the existing test
fixtures which contain examples of this situation.

*Performance*:
We pay a cost for this compared to the parent commit:
```
TreeRefIter()           time:   [50.403 ns 50.611 ns 50.830 ns]
                        change: [+8.6240% +9.0871% +9.5776%] (p = 0.00 < 0.05)
                        Performance has regressed.
```
but we already did enough optimizations to pay for this earlier in this
PR:
* `main`: `~55 ns`
* `parent`: `~46 ns`
* `this commit`: `~50 ns`

Fixes 1887

Author: pierrechevalier83

Diff for: gix-object/src/tree/mod.rs

@@ -64,7 +64,13 @@ impl TryFrom<u32> for tree::EntryMode {
 impl EntryMode {
     /// Expose the value as a u16 (lossy, unlike the internal representation that is hidden)
     pub const fn value(self) -> u16 {
-        self.internal
+        // Demangle the hack: In the case where the second leftmost octet is 4 (Tree), the leftmost bit is
+        // there to represent whether the bytes representation should have 5 or 6 octets
+        if self.internal & IFMT == 0o140000 {
+            0o040000
+        } else {
+            self.internal
+        }
     }
 
     /// Return the representation as used in the git internal format, which is octal and written
@@ -79,8 +85,14 @@ impl EntryMode {
                 let digit = (self.internal & oct_mask) >> bit_pos;
                 *backing_octet = b'0' + digit as u8;
             }
+            // Hack: `0o140000` represents `"040000"`, `0o40000` represents `"40000"`
             if backing[1] == b'4' {
-                &backing[1..6]
+                if backing[0] == b'1' {
+                    backing[0] = b'0';
+                    &backing[0..6]
+                } else {
+                    &backing[1..6]
+                }
             } else {
                 &backing[0..6]
             }
@@ -118,6 +130,10 @@ impl EntryMode {
             mode = (mode << 3) + (b - b'0') as u16;
             idx += 1;
         }
+        // Hack: `0o140000` represents `"040000"`, `0o40000` represents `"40000"`
+        if mode == 0o040000 && i[0] == b'0' {
+            mode += 0o100000;
+        }
         Some((Self { internal: mode }, &i[(space_pos + 1)..]))
     }
 

Diff for: gix-object/tests/object/tree/entry_mode.rs

@@ -70,10 +70,9 @@ fn as_bytes() {
             EntryMode::from_bytes(b"100644 ".as_ref()).expect("valid"),
             "100644".into(),
         ),
-        // Show incorrect behaviour: b"040000" doesn't round-trip
         (
             EntryMode::from_bytes(b"040000".as_ref()).expect("valid"),
-            "40000".into(),
+            "040000".into(),
         ),
         (EntryMode::from_bytes(b"40000".as_ref()).expect("valid"), "40000".into()),
     ] {

Diff for: gix-object/tests/object/tree/from_bytes.rs

@@ -101,6 +101,10 @@ fn special_trees() -> crate::Result {
             expected_entry_count,
             "{name}"
         );
+        // Show we can roundtrip
+        let mut buf: Vec<u8> = Default::default();
+        actual.write_to(&mut buf).expect("Failed to write bytes to buffer");
+        assert_eq!(buf, fixture);
     }
     Ok(())
 }