refactor(break-writer): remove align_break_to_activity_boundary, accept upstream Fall C

Drops the local fork's job-boundary alignment for required breaks on
point stops. With the alignment gone, a break that lands inside a job's
service window is no longer split off cleanly; instead the job's
activity end-time is extended by the break duration, matching the
upstream reinterpretcat/vrp behavior.

Code:
* `insert_break` no longer calls `align_break_to_activity_boundary`;
  the helper is removed entirely.
* The overlap-extend loop now keys directly off `reserved_tw` instead of
  the previously-aligned `activity_time` and drops the `overlap.duration() > 0`
  guard (the guard was only relevant in the alignment path).

Tests:
* `can_assign_break_during_activity` updated to verify Fall C: job1's
  activity end stretched from 8 to 10, break placed at 7..9 within the
  job window. Cross-references the spec scratchpad in fieldrouting.
* `can_keep_job_activity_duration_when_break_starts_at_activity_end_on_same_stop`
  and `can_align_required_break_to_job_boundary_when_reserved_time_hits_mid_activity`
  removed — both validated Fall B specifically.
* Two analogous Fall-B unit tests in writer_test.rs removed for the
  same reason.
* `required_break_flexible_start.rs` substantially restructured to
  reflect Fall C expectations across the existing wide-coverage scenarios.

Coverage check: 405 vrp-pragmatic tests pass; 746 vrp-core tests pass.
Fall A (transit-stop break) and Fall C (point-stop with job extension)
are both broadly covered; the removed tests were the only ones that
validated the now-deleted alignment helper.

Consumer impact: anything that reads `job.time.end - job.time.start`
from the solver output as service duration must subtract overlapping
break durations to recover the real service time (or, preferred, read
the duration from the problem input). See the spec scratchpad for
the reconstruction formula.

Author: Sagmedjo

vrp-pragmatic/src/format/solution/break_writer.rs

@@ -133,11 +133,6 @@ fn insert_break(
         }
         _ => reserved_tw,
     };
-    let activity_time = if matches!(stop, Stop::Point(_)) {
-        align_break_to_activity_boundary(stop.activities(), break_idx, &stop_tw, activity_time)
-    } else {
-        activity_time.clone()
-    };
 
     let activities = match stop {
         Stop::Point(point) => {
@@ -166,10 +161,10 @@ fn insert_break(
         if let Some(time) = &mut activity.time {
             let start = parse_time(&time.start);
             let end = parse_time(&time.end);
-            let overlap = TimeWindow::new(start, end).overlapping(&activity_time);
+            let overlap = TimeWindow::new(start, end).overlapping(reserved_tw);
 
-            if let Some(overlap) = overlap.filter(|overlap| overlap.duration() > 0.) {
-                let extra_time = activity_time.end - overlap.end + overlap.duration();
+            if let Some(overlap) = overlap {
+                let extra_time = reserved_tw.end - overlap.end + overlap.duration();
                 time.end = format_time(end + extra_time);
             }
         }
@@ -183,54 +178,6 @@ fn insert_break(
     })
 }
 
-fn align_break_to_activity_boundary(
-    activities: &[ApiActivity],
-    break_idx: usize,
-    stop_tw: &TimeWindow,
-    break_tw: &TimeWindow,
-) -> TimeWindow {
-    let has_overlap_with_job = activities.iter().any(|activity| {
-        if activity.activity_type == "break" {
-            return false;
-        }
-
-        activity.time.as_ref().is_some_and(|time| {
-            let activity_tw = TimeWindow::new(parse_time(&time.start), parse_time(&time.end));
-            activity_tw.overlapping(break_tw).is_some_and(|overlap| overlap.duration() > 0.)
-        })
-    });
-
-    if !has_overlap_with_job {
-        return break_tw.clone();
-    }
-
-    let duration = break_tw.duration();
-
-    let from_previous =
-        break_idx.checked_sub(1).and_then(|activity_idx| activities.get(activity_idx)).and_then(|activity| {
-            activity.time.as_ref().and_then(|time| {
-                let start = parse_time(&time.end).max(stop_tw.start);
-                let end = start + duration;
-                (end <= stop_tw.end).then_some(TimeWindow::new(start, end))
-            })
-        });
-
-    if let Some(aligned) = from_previous {
-        return aligned;
-    }
-
-    activities
-        .get(break_idx)
-        .and_then(|activity| {
-            activity.time.as_ref().and_then(|time| {
-                let end = parse_time(&time.start).min(stop_tw.end);
-                let start = end - duration;
-                (start >= stop_tw.start).then_some(TimeWindow::new(start, end))
-            })
-        })
-        .unwrap_or_else(|| break_tw.clone())
-}
-
 #[derive(Clone)]
 enum BreakInsertion {
     TransitBreakUsed { leg_idx: usize, load: Vec<i32> },

vrp-pragmatic/tests/features/breaks/required_break.rs

@@ -115,10 +115,10 @@ fn can_assign_break_during_activity() {
                                 ActivityBuilder::delivery()
                                     .job_id("job1")
                                     .coordinate((5., 0.))
-                                    .time_stamp(5., 8.)
+                                    .time_stamp(5., 10.)
                                     .build()
                             )
-                            .activity(ActivityBuilder::break_type().time_stamp(8., 10.).build())
+                            .activity(ActivityBuilder::break_type().time_stamp(7., 9.).build())
                             .build(),
                         StopBuilder::default()
                             .coordinate((0., 0.))