feat(r8-tests): Add R8 line number tests (#75)

Part of #40 

## R8 Retrace Test Coverage
- [x] Inlining (13 tests) - inline frames, line numbers, source files,
rewriteFrame rules
- [x] Ambiguous Methods (21 tests) - multiple methods → same obfuscated
name, <OR> alternatives
- [x] Outlines (4 tests) - outline callsites, nested outlines,
inline-in-outline
- [x] Synthetic/Lambda (3 tests) - lambda methods, synthetic bridges
- [x] Source File Edge Cases (7 tests) - colons, unicode, multiple dots,
synthesized names
- [x] Line Number Handling (10 tests) - spans, preambles, invalid
ranges, missing lines
- [ ] Exception Handling (6 tests) - obfuscated exceptions, suppressed,
circular refs
- [ ] Method Overloading (4 tests) - overloads with/without ranges
- [ ] Special Formats (4 tests) - Java 9+ modules, logcat format,
auto-detect

---------

Co-authored-by: Claude Opus 4.6 <noreply@anthropic.com>

Author: romtsn

src/builder.rs

@@ -149,12 +149,12 @@ pub(crate) struct RewriteRule<'s> {
 pub(crate) struct Member<'s> {
     /// The method the member refers to.
     pub(crate) method: MethodKey<'s>,
-    /// The obfuscated/minified start line.
-    pub(crate) startline: usize,
-    /// The obfuscated/minified end line.
-    pub(crate) endline: usize,
-    /// The original start line.
-    pub(crate) original_startline: usize,
+    /// The obfuscated/minified start line, `None` when no minified range prefix was present.
+    pub(crate) startline: Option<usize>,
+    /// The obfuscated/minified end line, `None` when no minified range prefix was present.
+    pub(crate) endline: Option<usize>,
+    /// The original start line, `None` when no line mapping was present.
+    pub(crate) original_startline: Option<usize>,
     /// The original end line.
     pub(crate) original_endline: Option<usize>,
     /// Optional outline callsite positions map attached to this member.
@@ -291,20 +291,31 @@ impl<'s> ParsedProguardMapping<'s> {
                     } else {
                         None
                     };
-                    // in case the mapping has no line records, we use `0` here.
-                    let (startline, endline) =
-                        line_mapping.as_ref().map_or((0, 0), |line_mapping| {
-                            (line_mapping.startline, line_mapping.endline)
-                        });
-                    let (original_startline, original_endline) =
-                        line_mapping.map_or((0, None), |line_mapping| {
-                            match line_mapping.original_startline {
-                                Some(original_startline) => {
-                                    (original_startline, line_mapping.original_endline)
-                                }
-                                None => (line_mapping.startline, Some(line_mapping.endline)),
-                            }
-                        });
+                    let (mut startline, mut endline) = match line_mapping.as_ref() {
+                        Some(lm) => (lm.startline, lm.endline),
+                        None => (None, None),
+                    };
+                    let (mut original_startline, mut original_endline) = match line_mapping {
+                        None => (None, None),
+                        Some(lm) => match lm.original_startline {
+                            Some(os) => (Some(os), lm.original_endline),
+                            None => (startline, endline),
+                        },
+                    };
+
+                    // Normalize inverted ranges independently.
+                    if let (Some(s), Some(e)) = (startline, endline) {
+                        if s > e {
+                            startline = Some(e);
+                            endline = Some(s);
+                        }
+                    }
+                    if let (Some(os), Some(oe)) = (original_startline, original_endline) {
+                        if os > oe {
+                            original_startline = Some(oe);
+                            original_endline = Some(os);
+                        }
+                    }
 
                     let Some((current_class_obfuscated, current_class_original)) =
                         current_class_name