print: bypass the multiline mode of pretty_string_literal for merely trailing \n. (#27)

At some point I added a multiline pretty string format using
Rust-compatible string continuations, i.e. `\` at the end of a line
ignores all whitespace following it, so these are equivalent Rust
literals:
```rust
"foo\
         \n"
```
```rust
"foo\n"
```
```rust
"foo
"
```
(the last one is never used by `spirt::pretty`, because it cannot be
indented without changing the meaning of the string literal, and
`spirt::print::pretty` assumes *everything* can be indented)

This PR ignores trailing `\n` when determining whether the multiline
format should be used, i.e. only `\n` *in the middle* of a string will
use `\` continuations (with the `\n` moved to the start of following
lines).

---

Quick example (the very one that made me think it'd be worth a minor
aesthetic improvement):
|Before|After|
|-|-|
|<img width="1276" height="1127" alt="image"
src="https://github.com/user-attachments/assets/7f6bdb20-79ff-4f25-b2f9-e9b961578bac"
/>|<img width="2066" height="566" alt="image"
src="https://github.com/user-attachments/assets/afca8cba-0d00-45fd-ba66-bbd059238a88"
/>|

Author: LegNeato

src/print/mod.rs

@@ -1723,12 +1723,16 @@ impl Printer<'_> {
 
     /// Pretty-print a string literal with escaping and styling.
     fn pretty_string_literal(&self, s: &str) -> pretty::Fragment {
+        // HACK(eddyb) avoid using multiline formatting for trailing `\n`, which
+        // may be common in e.g. `debugPrintf("foo\n")`-style messages.
+        let use_multiline_format = s.trim_end_matches('\n').contains('\n');
+
         // HACK(eddyb) this is somewhat inefficient, but we need to allocate a
         // `String` for every piece anyway, so might as well make it convenient.
         pretty::Fragment::new(
             // HACK(eddyb) this allows aligning the actual string contents,
             // (see `c == '\n'` special-casing below for when this applies).
-            (s.contains('\n').then_some(Either::Left(' ')).into_iter())
+            (use_multiline_format.then_some(Either::Left(' ')).into_iter())
                 .chain([Either::Left('"')])
                 .chain(s.chars().flat_map(|c| {
                     let escaped = c.escape_debug();
@@ -1747,7 +1751,8 @@ impl Printer<'_> {
                     // HACK(eddyb) move escaped `\n` to the start of a new line,
                     // using Rust's trailing `\` on the previous line, which eats
                     // all following whitespace (and only stops at the escape).
-                    let extra_prefix_unescaped = if c == '\n' { "\\\n" } else { "" };
+                    let extra_prefix_unescaped =
+                        if c == '\n' && use_multiline_format { "\\\n" } else { "" };
 
                     (extra_prefix_unescaped.chars().map(Either::Left)).chain([maybe_escaped])
                 }))