feat(graph): match GitX's graph, column for column

[LeadcodeDev]

gitr's graph did not match GitX's. Four independent causes, all now fixed and all verified
by measurement rather than by looking.

1. The commit order

git --topo-order : … ac3641b, 1bc10ae, 0bd5615, c9eba26, b0aee11 …   ← gitr
git --date-order : … ac3641b, 1bc10ae, c9eba26, 0bd5615, b0aee11 …   ← GitX

Topological order interleaves a branch's commits with the trunk whenever their dates
interleave. Date order keeps each branch's run contiguous, which is what lets a branch hold
a column for several rows instead of appearing as a one-commit stub.

topo::Sorting::TopoOrder → DateOrder. Reproduces git rev-list --date-order exactly;
the two sequences diff clean.

The measurement that justified topological order no longer describes this code

CLAUDE.md argued for it with rust-lang/cargo at 23 789 commits: 258 lanes in date order
against 20. Measured on the current code, zed-industries/zed at 39 565 commits gives
13 columns in date order against 17 topologically — date order is the narrower of the
two here. Different repository and different code, so the honest claim is that row, not
"258 became 13".

2. The lane placement

Ported PBGitGrapher.decorateCommit rather than adapting what was here.

Verified by running GitX's own algorithm over this repository's history and diffing the
column of every commit:

	identical	differing
before	43 / 53	10, all by one column, all the same direction
after	53 / 53	0

Two things were wrong, and only one of them was visible.

Convergence was eager. gitr folded a lane away as soon as another column already
expected its first parent. GitX does not check — currentLane->setSha(parents[0]) is
unconditional — so two columns can hold the same object and meet only at the row that
places it. Closing a column one row early slides everything to its right, which is exactly
the offset those ten commits showed.

The node was placed in the wrong space. GitX puts a commit at its index in the
outgoing column list; gitr used the incoming one. They agree until a column dies in the
same row a tip appears, and then they do not. That is not a parameter to tweak — it is the
frame the whole line model is expressed in, which is why two attempts to patch it in place
made things worse (ten divergences became eighteen) before this rewrite.

A parentless commit leaves a hole rather than closing its column, so its neighbours hold
position one more row — GitX does this too, with std::replace(…, currentLane, 0).

3. The shape of a line

Correct columns still drew the wrong picture. A segment described the whole band between
two rows, so a branch leaving its parent ran vertically down to the row boundary, turned,
and only then slanted across. Every divergence therefore started a half-row below the node
it came from, and every convergence arrived a half-row above the one it went to.

GitX has no bend anywhere. PBGitRevisionCell.drawLineFromColumn draws one straight line
from a cell edge to the cell's own centre, and nothing else. A change of column happens
over half a row, and every line ends on a node rather than beside it.

GraphRow is split to match:

• incoming — the lines crossing the upper half, from the top edge down to the row's centre
• segments — the lines crossing the lower half, from that centre down to the bottom edge

A line changing column does so above the node, arriving already in its new one. IncomingLink
and the midpoint machinery it fed are gone, as are next_lane, is_outgoing and
lands_on_next_node, which existed only to reconstruct a bend nothing draws any more.

Placement is untouched by this third fix — the column comparison still reports 53 / 53.

4. The node

gitr drew a small disc in the lane's colour. GitX draws two concentric circles and no lane
colour at all — drawCircleInRect fills a black oval of diameter 10, then a white one of
diameter 8 over it, leaving a thin ring. Sampled off a GitX window on this repository to
confirm the source reads the way it looks: ring #020202, fill #ffffff, and #fca64f
on the one node that is the checked-out commit.

The hollow centre is ported as written, reading the fill from the theme so the shape
survives dark mode. Two things deliberately depart from GitX:

The ring takes the track's colour, where GitX paints every one black. A ring in the
branch's colour says which branch a commit belongs to without following its line up the
gutter, and the hollow centre is what leaves room to say it — a filled disc in the same
colour reads as a thickening of the line, which is exactly what gitr drew before.

The node is three quarters of its column, not the full width GitX uses. Its rows are
20px and its columns 10px; gitr's are 24 and 12, so an edge-to-edge node put adjacent lanes
in contact and a run of parallel branches read as a band. Shrinking one that way thins its
ring away, so the inner radius is subtracted from the outer rather than taken as a fraction
of it, and a test pins that the centre stays hollow and that neighbours stay apart.

The pixel grid, which took three passes to state correctly

Resizing the node exposed a class of bug the geometry cannot show, and each pass fixed one
case and named the rule too narrowly for the next.

The ring came out 2px on one side, 1px on the other. The arithmetic was symmetric, so
the cause was the snapping applied after it: a 1.2px ring put the two discs' origins on
different sub-pixel offsets and they rounded apart. Measured, not judged by eye — the fill
spanned dx -3..+2 inside an outer disc spanning -5..+3.

Diagonals then read as doubled. A sloped line was painted 1.4× the vertical one, to
compensate for a 1.5px vertical landing at four fifths opacity. Once the line went to 2px
and landed as two solid columns, the factor corrected nothing and just made the line
thicker. One width now, and no branch on the slope. A 45° line still covers more
horizontal pixels — five against two — but that is its slope, not its weight.

Then the lines sat half a pixel off the nodes. The node covered pixels 332..340,
centre 336.5; the line covered 336..337, centre 337. A radius of 4.5 has a fractional
half-extent where a 2px line's is whole.

The rule that covers all three: every half-extent in the gutter must be a whole number
— a radius for a disc, half a width for a line — because that is what gets snapped, and
shapes on one centre stay centred only when their half-extents share a fractional part. The
test asserts it over all three half-extents rather than over the conditions each bug
suggested, since naming conditions is exactly what let the later ones through. CLAUDE.md
records it.

The checked-out commit keeps GitX's #fca64f and is the only filled node in the table, so
it reads down the whole gutter without depending on the ring's colour.

HEAD reaches the delegate as an ObjectId now, not only as a branch name.
HeadState::target() is what GitX compares against, and it is the only thing still saying
where you are when HEAD is detached.

What was reverted

Stable columns, from #41. They were a response to "gitr only parallelises two branches",
and that diagnosis was wrong twice: instrumenting the layout showed three columns already
in use, and the real divergence was the ordering above. Stable columns are arguably easier
to follow — but GitX compacts, and matching GitX is the requirement.

Tests

The layout tests are rewritten, not patched. That is a real loss of evidence and worth
being explicit about: through cause 2 they passed untouched, which was the strongest
available proof that the placement was a port rather than a rewrite wearing its name. Cause
3 changes what a row means — an assertion on segments no longer describes the same band
— so keeping the old text would have asserted the old model in the new one's vocabulary.
Each test now names which half it reads, and the values were taken from the layout's actual
output on fixtures small enough to verify by hand.

Placement is what those tests protected, and placement is covered by the column comparison
against GitX, which is a stronger check than any of them.

crates/ui/src/history/geometry.rs carries the pixel-level half: a line from above ends
exactly on the node centre, a merge's second parent leaves the node sideways, a tip has
nothing drawn above it, a root nothing below.

cargo test --workspace green; cargo clippy --workspace --all-targets -- -D warnings;
cargo fmt --all --check.

Verification

Driven on the running app, and measured: GitX's algorithm ported to a script, run over the
real history, every column diffed. The final shape was checked by capturing gitr's window
and GitX's window on this same repository and scaling both gutters to a common row pitch —
the two are the same figure. CLAUDE.md records the details the port turns on and that
same check as the way to validate any future change here.