flomni: add laser_parameters CLI and laser_tweak tool

Expose the ConstEmitter runtime constants through the high-level flomni
interface, alongside the existing laser_tracker_* methods, and add an
interactive tweak tool for the two tracking target positions.

New methods on FlomniSampleTransferMixin (thin wrappers delegating to
dev.rtx.controller, same pattern as laser_tracker_show_all):
  laser_parameters_show_all()
  laser_parameters_set_targety(val)
  laser_parameters_set_targetz(val)
  laser_parameters_set_intensity_threshold_laser(val)
  laser_parameters_set_psd_intensity_threshold_tracking_low(val)

laser_tweak(): interactive 2D raw-terminal loop for the two tracking targets,
modeled on OMNYTools.tweak_cursor.
  left/right : target y -/+   (fixed 0.01 step, absolute set of current +/- step)
  up/down    : target z +/-
  s          : return both targets to their launch positions
  q          : quit (terminal state restored in finally)
On launch and after every change it prints the current y/z targets and the
fzp x interferometer signal (read_ssi_interferometer channel 1), so the signal
response can be watched while tweaking.

termios/tty/fcntl/sys are imported locally in laser_tweak to avoid touching
module-level imports. Additive change; no existing behaviour modified. Requires
the ConstEmitter emitter_* methods on RtFlomniController.

csaxs_bec/bec_ipython_client/plugins/flomni/flomni.py

@@ -465,6 +465,116 @@ class FlomniSampleTransferMixin:
     def laser_tracker_off(self):
         dev.rtx.controller.laser_tracker_off()
 
+    def laser_parameters_show_all(self):
+        dev.rtx.controller.emitter_show_all()
+
+    def laser_parameters_set_targety(self, val: float):
+        dev.rtx.controller.emitter_set_tracking_target_y(val)
+
+    def laser_parameters_set_targetz(self, val: float):
+        dev.rtx.controller.emitter_set_tracking_target_z(val)
+
+    def laser_parameters_set_intensity_threshold_laser(self, val: float):
+        dev.rtx.controller.emitter_set_intensity_threshold_laser(val)
+
+    def laser_parameters_set_psd_intensity_threshold_tracking_low(self, val: float):
+        dev.rtx.controller.emitter_set_psd_intensity_threshold_tracking_low(val)
+
+    def laser_tweak(self):
+        """Interactive tweak of the two laser tracking target positions.
+
+        Arrow keys nudge the ConstEmitter tracking targets by a fixed step of
+        0.01 (absolute set of current +/- step):
+            left / right : target y  -/+
+            up   / down  : target z  +/-
+        Keys:
+            s : return both targets to the positions they had at launch
+            q : quit
+
+        After every change the current y/z targets and the fzp x interferometer
+        signal strength (channel 1) are printed, so one can watch the signal
+        respond while tweaking.
+        """
+        import fcntl
+        import sys
+        import termios
+        import tty
+
+        step = 0.01
+        controller = dev.rtx.controller
+
+        def read_targets():
+            values = controller.emitter_get()
+            return (
+                values["targetpos_tracking_y"],
+                values["targetpos_tracking_z"],
+            )
+
+        def signal_fzpx():
+            # second channel (index 1) of show_signal_strength_interferometer,
+            # i.e. the fzp x channel / tracker signal
+            return controller.read_ssi_interferometer(1)
+
+        def print_status():
+            target_y, target_z = read_targets()
+            print(
+                f"\rtarget y: {target_y:.4f}   target z: {target_z:.4f}   "
+                f"fzp x signal: {signal_fzpx():.1f}\r"
+            )
+
+        # capture launch positions for the 's' (return to start) command
+        start_y, start_z = read_targets()
+
+        print(
+            "Laser tweak. "
+            + self.OMNYTools.BOLD
+            + self.OMNYTools.OKBLUE
+            + "left/right: target y,  up/down: target z,  s: start pos,  q: quit\r"
+            + self.OMNYTools.ENDC
+        )
+        print_status()
+
+        fd = sys.stdin.fileno()
+        old_term = termios.tcgetattr(fd)
+        try:
+            tty.setraw(fd)
+            old_flags = fcntl.fcntl(fd, fcntl.F_GETFL)
+            fcntl.fcntl(fd, fcntl.F_SETFL, old_flags | os.O_NONBLOCK)
+            while True:
+                try:
+                    key = sys.stdin.read(1)
+                    if key == "q":
+                        print("\n\rExiting tweak mode\r")
+                        break
+                    elif key == "s":
+                        controller.emitter_set_tracking_target_y(start_y)
+                        controller.emitter_set_tracking_target_z(start_z)
+                        print("\rReturned to start positions\r")
+                        print_status()
+                    elif key == "\x1b":  # escape sequences for arrow keys
+                        next1, next2 = sys.stdin.read(2)
+                        if next1 == "[":
+                            target_y, target_z = read_targets()
+                            if next2 == "A":  # up: target z +
+                                controller.emitter_set_tracking_target_z(target_z + step)
+                                print_status()
+                            elif next2 == "B":  # down: target z -
+                                controller.emitter_set_tracking_target_z(target_z - step)
+                                print_status()
+                            elif next2 == "C":  # right: target y +
+                                controller.emitter_set_tracking_target_y(target_y + step)
+                                print_status()
+                            elif next2 == "D":  # left: target y -
+                                controller.emitter_set_tracking_target_y(target_y - step)
+                                print_status()
+                except IOError:
+                    pass
+
+                time.sleep(0.02)
+        finally:
+            termios.tcsetattr(fd, termios.TCSADRAIN, old_term)
+            fcntl.fcntl(fd, fcntl.F_SETFL, old_flags)
+
     def umvr_fsamy_tracked(self, shift: float, step: float = 0.01, _internal: bool = False):
         """
         Relative move of fsamy by `shift` mm, broken into steps of at most