Acquisition errors return to Idle instead of Error state

Going to the Error state after any acquisition failure forced an expensive
re-initialisation (reconnect + full detector config + pedestals), even when the
detector was still perfectly configured and only a transient problem occurred.

Split failures into two classes:
 - ordinary acquisition failures (receiver/writer/analysis problems, missed
   packets, writer disconnect) return to Idle with an Error-severity message, so
   the run can be retried without re-initialising;
 - failures that leave the detector in an undefined state throw the new
   JFJochCriticalException and still go to Error, forcing re-initialisation.

The detector layer is the single source of truth for "detector faulted":
SLSDetectorWrapper::InternalStop and DectrisDetectorWrapper::CheckBusyOrError
raise JFJochCriticalException on the ERROR state, and JFJochServices::Stop raises
it when the detector does not return to idle at the end of a run. MeasurementThread
dispatches purely on exception type - no detector-status field checks.

Also:
 - JFJochServices::Start now stops the receiver it launched if the detector fails
   to start, so the service returns to idle cleanly and the run can be retried.
 - A synchronous Start rethrows the failure to the caller (HTTP layer) via a
   stored exception_ptr, so a failed start is no longer reported as HTTP 200.
 - JFJochServices::Stop no longer throws on a writer error; it is reported through
   receiver_output.writer_err and surfaced as an Idle + Error-severity message,
   which makes the previously-dead writer_err branch in MeasurementThread live.

Initialisation, calibration/pedestal, SelectDetector and Deactivate keep the
Error-state behaviour, as those genuinely leave the system in an undefined state.

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

detector_control/SLSDetectorWrapper.cpp

@@ -217,6 +217,8 @@ void SLSDetectorWrapper::Start(const DiffractionExperiment& experiment) {
         det.setNumberOfTriggers(experiment.GetNumTriggers());
 
         det.startDetector();
+    } catch (const JFJochException &) {
+        throw; // already a categorised JFJoch exception (incl. critical detector error) - keep its type
     } catch (std::exception &e) {
         logger.ErrorException(e);
         throw JFJochException(JFJochExceptionCategory::Detector, e.what());
@@ -229,7 +231,7 @@ void SLSDetectorWrapper::InternalStop() {
     // Assume it is executed in try-catch!
     auto state = GetState();
     if (state == DetectorState::ERROR)
-        throw JFJochException(JFJochExceptionCategory::Detector, "Detector in error state");
+        throw JFJochCriticalException("Detector in error state");
     else if ((state == DetectorState::BUSY) || (state == DetectorState::WAITING)) {
         try {
             det.stopDetector();