Adjust some nits in trait solver text

Co-authored-by: lcnr <rust@lcnr.de>

Author: Mark-Simulacrum

posts/2025-01-09-Rust-1.84.0.md

@@ -69,7 +69,7 @@ automatically use older library versions compatible with their older toolchain.
 
 See the [documentation](https://doc.rust-lang.org/cargo/reference/rust-version.html#setting-and-updating-rust-version) for more considerations when deciding on an MSRV policy.
 
-### Migration to a new trait solver begins
+### Migration to the new trait solver begins
 
 The Rust compiler is in the process of moving to a new implementation for the
 trait solver. The next-generation trait solver is a reimplementation of a core
@@ -81,16 +81,15 @@ underlying type of `<Vec<T> as IntoIterator>::Item` - and equating types
 
 In 1.84, the new solver is used for checking coherence of trait impls. At a
 high level, coherence is responsible for ensuring that there is at most one
-implementation of a trait for a given type, including *globally* in not yet
-written or visible code in downstream crates from the current compilation.
-
-This stabilization does include some breaking changes, primarily by fixing some
-correctness issues with the old solver. Typically these will show up as new
-"conflicting implementations of trait ..." errors that were not previously
-reported. We expect instances of this to be rare based on evaluation of
-available code through [Crater], as the soundness holes in the previous solving
-engine used relatively esoteric code. It also improves our ability to detect
-where impls do *not* overlap, allowing more code to be written in some cases.
+implementation of a trait for a given type while considering not yet written
+or visible code from other crates.
+
+This stabilization fixes a few mostly theoretical correctness issues of the
+old implementation, resulting in potential "conflicting implementations of trait ..."
+errors that were not previously reported. We expect the affected patterns to be
+very rare based on evaluation of available code through [Crater]. The stabilization
+also improves our ability to prove that impls do *not* overlap, allowing more code
+to be written in some cases.
 
 For more details, see a [previous blog post](https://blog.rust-lang.org/inside-rust/2024/12/04/trait-system-refactor-initiative.html)
 and the [stabilization report](https://github.com/rust-lang/rust/pull/130654).