Auffahrkeile: Höhe je Rad statt getrennt für quer und längs

Bisher standen dort zwei Angaben nebeneinander, etwa "rechts 8 cm" und
"vorne 4 cm". Das liest sich wie zwei Aufgaben, ist aber eine: Unter
"rechts" liegen zwei Räder, unter "vorne" auch, und eines davon ist
dasselbe. Ausführen lässt sich das so nicht.

Gerechnet wird jetzt über alle vier Aufstandspunkte auf einmal. Aus
Spurweite, Radstand und den beiden Winkeln ergeben sich deren Höhen;
angehoben wird auf das höchststehende Rad, das liegen bleibt. Aus dem
Beispiel oben werden damit 12 cm vorne rechts, 8 cm hinten rechts, 4 cm
vorne links und nichts hinten links – dieselbe Geometrie, nur richtig
zusammengesetzt.

Angezeigt wird das als Draufsicht auf das Fahrzeug (WheelLiftPlan), auf
iPhone und Uhr dieselbe Ansicht, auf der Uhr kompakt. LevelingWedge
entfällt.

Abgesichert in run-tests.sh: reine Querneigung, reine Längsneigung,
beides zusammen (16,1 / 9,2 / 7,0 / 0 cm), gespiegelte Vorzeichen und
die Fälle ohne Fahrzeugmasse.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

CamperMonitor/Views/AlignmentAssistantView.swift

@@ -176,37 +176,37 @@ struct AlignmentAssistantView: View {
 
     @ViewBuilder
     private var wedgeSection: some View {
-        let across = profile?.trackWidth.flatMap { width in
-            state.roll.flatMap { LevelingWedge.across(roll: $0, trackWidth: width) }
-        }
-        let along = profile?.wheelbase.flatMap { base in
-            state.pitch.flatMap { LevelingWedge.along(pitch: $0, wheelbase: base) }
-        }
+        // Gerechnet wird über alle vier Räder auf einmal. Getrennte Angaben für
+        // quer und längs beschreiben dasselbe Fahrzeug und lassen sich nicht
+        // getrennt ausführen: Unter „rechts" liegen zwei Räder, unter „vorne"
+        // auch, und eines davon ist dasselbe.
+        let lift: LevelingLift? = {
+            guard let width = profile?.trackWidth, let base = profile?.wheelbase,
+                  let pitch = state.pitch, let roll = state.roll else { return nil }
+            return LevelingLift.compute(pitch: pitch, roll: roll,
+                                        trackWidth: width, wheelbase: base)
+        }()
 
         VStack(alignment: .leading, spacing: 10) {
             Label("Auffahrkeile", systemImage: "triangle.fill")
                 .font(.headline)
 
-            if profile?.trackWidth == nil && profile?.wheelbase == nil {
+            if profile?.trackWidth == nil || profile?.wheelbase == nil {
                 Text("Für die Keilhöhe fehlen Spurweite und Radstand. Beides lässt "
                      + "sich beim Fahrzeug hinterlegen.")
                     .font(.callout)
                     .foregroundStyle(.secondary)
-            } else if across == nil && along == nil {
-                Text("Keine Keile nötig.")
-                    .font(.callout)
+            } else if let lift, !lift.isNegligible {
+                WheelLiftPlan(lift: lift)
+                    .frame(maxWidth: .infinity)
+
+                Text("Zentimeter unter das jeweilige Rad. Das höchststehende Rad "
+                     + "bleibt liegen, die übrigen werden auf seine Höhe gebracht.")
+                    .font(.caption)
                     .foregroundStyle(.secondary)
             } else {
-                ForEach([across, along].compactMap { $0 }, id: \.side) { wedge in
-                    HStack {
-                        Text(wedge.side.text.capitalized)
-                        Spacer()
-                        Text(String(format: "%.0f cm", wedge.heightInCentimetres))
-                            .font(.title3.weight(.semibold).monospacedDigit())
-                    }
-                }
-                Text("Höhe unter die tieferstehende Seite, damit das Fahrzeug eben steht.")
-                    .font(.caption)
+                Text("Keine Keile nötig.")
+                    .font(.callout)
                     .foregroundStyle(.secondary)
             }
         }
@@ -230,4 +230,3 @@ struct AlignmentAssistantView: View {
     }
 }
 
-extension LevelingWedge.Side: Hashable {}