Read code as literal text, and put its panel on the theme

[scottjones]

Identifiers with underscores were being mangled in the editor. Between
backticks, default_line_height came out italic with its underscores hidden,
and the caret skipped over them as though they were markup — the inline rules
ran over the raw line and never noticed the code span. Fenced blocks had the
same problem for a different reason: the highlighter had no memory of being
inside one, so a code block was read as prose.

Before:

After:

Three changes: inline code is read as literal text; underscores now need a word
boundary to open emphasis, the way CommonMark and GitHub read them, so
snake_case_name survives in plain prose too; and fenced blocks are left alone
end to end. Asterisks still delimit anywhere, and Ctrl+B / Ctrl+I insert
asterisks, so the toolbar is unaffected. While in there, the panel code sits on
was a hardcoded #1c1a1a that clashed with every theme — it now takes the
lighter background the Omarchy theme names, falling back to a shade mixed from
the page for the themes that omit it or set it equal to the background.

One deliberate rough edge: the panel is painted per character, so a fenced
block's right edge steps with line length and a blank line inside a block gets
no panel at all. A continuous one needs either a block format the highlighter
can't set or a rectangle layer in QML, and neither seemed worth it here.

Test plan

• bin/test passes (16 tests)
• Inline code with underscores stays literal, and the caret walks through it
  a character at a time instead of jumping
• Emphasis still works: _italic_, *italic*, **bold**, __bold__,
  Ctrl+B and Ctrl+I
• snake_case_name in prose is left alone
• Fenced block contents are unstyled, and a # comment on its own line
  inside a block is not set as a heading
• The code panel follows the theme in both light and dark mode

Verified by hand on osaka-jade (dark) and in light mode.

🤖 Generated with Claude Code

[omarchybot]

Reviewed both halves against the source and on a disposable VM. bin/test builds clean and all 16 tests pass on Qt 6.11.1. Nothing pushed — everything below is minor, and the two behaviour questions are yours to call.

The theme half holds up under the checks I had doubts about. m_themeLighterBackground.clear() at backend.cpp:599 is unconditional with no early return above it, and loadOmarchyTheme() is the only writer, so switching themes at runtime cannot inherit the previous theme's panel. .name() is never taken on an invalid QColor — lighter.isValid() guards the theme string and blend() always returns a valid fromRgbF colour — and that guard is load-bearing, since QColor("garbage").name() is #000000, which would have put a black panel on a light theme. The 6% mix measures #0f0f0f (lightness 15) on a pure black page and #f0f0f0 (240) on a pure white one, so the comment's claim about mixing beating lightening is right. All 22 stock themes ship lighter_background, and the only two where it equals the page — last-horizon and solitude — are exactly the fallback case; they land on #1a191a and #1b1e20.

Three small things:

• markdownhighlighter.cpp:118 stores the closing fence line as Prose — opening and interior lines get InsideFence, the closing one does not. That is what your own test asserts and it matches the fence-parity convention smartReturn() already uses in Main.qml, so it is defensible. The consequence is that backend.cpp:387 does not take its early return on that line: hiddenRangesAt() parses it as prose while highlightBlock() has painted the whole line with m_fenceFormat and hidden nothing. For a bare ``` no ranges come back and it is harmless, but on a line like ``` **x** the caret skips over four characters the user can see. Cheapest fix is to widen the guard to cover a fence line as well as an interior one.
• markdownhighlighter.cpp:225 — codeSpans() does not honour a backslash-escaped backtick, and it now decides whether emphasis is dropped rather than only where a panel is drawn. use \ in code like `x`renderscode` italic on master and renders it literally here. CommonMark agrees with your version for that particular line, so this is arguably a fix, but escaped backticks are a real divergence.
• The comment at markdownhighlighter.cpp:245 says markup that merely wraps a code span still applies, and the markup does — but the code span loses its panel while doing so. setFormat() replaces rather than merges, so the bold format applied over the content wipes the background: for **\file_name` only**` the whole run comes back with no background and visible backticks. This is not something you introduced — master does exactly the same — but the comment reads like a promise the rendering does not quite keep.

Unterminated fences behave correctly: every remaining block stays InsideFence to end of document, which is what CommonMark specifies, and the initial previousBlockState() == -1 is handled. Qt's incremental rehighlighting cascades properly when a fence is typed, deleted or split.

Heads up that PRs #5, #8, #15 and #17 all touch src/markdownhighlighter.{h,cpp} and tests/tst_omawrite.cpp; #15 adds another inline kind and will want the same code-span exclusion this PR introduces.