fix(r8): Normalize inverted line ranges in mapping parser

Inverted minified ranges (e.g. `5:3:void main() -> main`) and inverted
original ranges (e.g. `2:5:void main():5:2 -> main`) are now normalized
by swapping the start/end values. This fixes incorrect line interpolation
for these edge cases.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: romtsn

src/builder.rs

@@ -292,11 +292,11 @@ impl<'s> ParsedProguardMapping<'s> {
                         None
                     };
                     // in case the mapping has no line records, we use `0` here.
-                    let (startline, endline) =
+                    let (mut startline, mut endline) =
                         line_mapping.as_ref().map_or((0, 0), |line_mapping| {
                             (line_mapping.startline, line_mapping.endline)
                         });
-                    let (original_startline, original_endline) =
+                    let (mut original_startline, mut original_endline) =
                         line_mapping.map_or((0, None), |line_mapping| {
                             match line_mapping.original_startline {
                                 Some(original_startline) => {
@@ -306,6 +306,22 @@ impl<'s> ParsedProguardMapping<'s> {
                             }
                         });
 
+                    // Normalize inverted ranges: if minified range is inverted,
+                    // swap both minified and original pairs.
+                    if startline > endline {
+                        std::mem::swap(&mut startline, &mut endline);
+                        if let Some(ref mut oe) = original_endline {
+                            std::mem::swap(&mut original_startline, oe);
+                        }
+                    }
+                    // If original range is still inverted, swap it independently.
+                    if let Some(oe) = original_endline {
+                        if original_startline > oe {
+                            original_endline = Some(original_startline);
+                            original_startline = oe;
+                        }
+                    }
+
                     let Some((current_class_obfuscated, current_class_original)) =
                         current_class_name
                     else {