refactor: restructure lidarlib into xlidar-driver plugin SDK

- LidarManager facade (liblidar_manager.so): dlopen plugin discovery,
  available_drivers map<driver_id, PluginRegistry>, create_lidar_device,
  config.json load/save with legacy lidarlib migration
- Common LidarDriverInterface + DriverInfo/DeviceConfig plugin ABI
  (extern C get_driver_info / create_driver_instance)
- Plugins: driver_rplidar (ported from xlocd, Slamtec SDK), driver_olei,
  driver_sick_code (TiM CoLa-A), driver_sick_safety (nanoScan3), driver_espe
- Diagnostics extended with rplidar health + firmware; FOV filter window,
  range override and legacy remap window unified in DeviceConfig
- Rewritten README, diagnostics doc and examples (list_drivers, example,
  lidar_app)

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

plugins/driver_espe/espe_driver.hpp

@@ -0,0 +1,87 @@
+// ESPE LGA60 laser scanner over TCP or UDP — plugin-private header.
+#pragma once
+#include "lidar_interface.hpp"
+
+#include <cstdint>
+#include <optional>
+#include <string>
+#include <vector>
+
+namespace xlidar {
+
+// ESPE LGA60-320: 320° FOV, device sweeps 20°..340° with 0° at the rear
+// (angle_offset_deg = -180 so output 0° = ahead). Range per datasheet page;
+// the wire caps distance at 50000 mm.
+inline constexpr ModelConfig MODEL_ESPE_LGA60 { "ESPE-LGA60", -160.f, 160.f, 0.05f, 50.f, -180.f };
+
+// ESPE LGA60 over TCP (default port 8080) or UDP, ported from the vendor's
+// ROS driver; NOT verified on real hardware. open() sends the "RAuto" start
+// command; device parameters (spin rate, resolution, filters) are whatever
+// the vendor Windows config tool programmed — this driver does not set them.
+class EspeDriver : public LidarDriverInterface {
+public:
+    // ip: device address; use_udp selects the transport the device is
+    // configured for (vendor default is TCP); inverted: unit mounted
+    // upside-down → mirror the scan.
+    explicit EspeDriver(const ModelConfig& cfg,
+                        const std::string& ip,
+                        uint16_t            port     = 8080,
+                        bool                use_udp  = false,
+                        bool                inverted = false);
+    ~EspeDriver();
+
+    EspeDriver(const EspeDriver&)            = delete;
+    EspeDriver& operator=(const EspeDriver&) = delete;
+
+    DriverInfo get_driver_info() const override;
+
+    // Connect + send the start-capture command.
+    ErrorCode open() override;
+    void close() override;
+    bool recv_scan(ScanResult& out, int timeout_ms = 1000) override;
+    void set_scan_callback(ScanCallback cb) override { cb_ = std::move(cb); }
+    bool spin_once() override;
+    bool is_open() const override { return sock_fd_ >= 0; }
+
+    // No model string on the wire — returns the configured name.
+    const char* detected_model() const override { return detected_model_name_.c_str(); }
+
+    Diagnostics get_diagnostics() const override { return latest_diag_; }
+
+private:
+    bool fill_buffer(int timeout_ms);   // one recv() into recv_buf_
+    bool parse_buffer();                 // consume frames; true when a scan completed
+    void handle_range_frame(const uint8_t* frame, uint16_t data_size);
+    void finish_scan();
+
+    ModelConfig  cfg_;
+    std::string  detected_model_name_;  // owned copy of cfg_.name (stable lifetime)
+    std::string  ip_;
+    uint16_t     port_;
+    bool         use_udp_  = false;
+    bool         inverted_ = false;
+    int          sock_fd_ = -1;
+    ScanCallback cb_;
+
+    // Stream bytes carried across frame boundaries; per-instance.
+    std::string recv_buf_;
+
+    // Per-revolution accumulation
+    std::vector<float> pending_ranges_;
+    std::vector<float> pending_intensities_;
+    float    rev_start_deg_ = 0.f;  // device angle of the revolution's first point
+    float    angle_inc_deg_ = 0.f;
+    uint32_t points_total_  = 0;    // measure_size from the header; 0 = no rev open
+    uint16_t pending_time_  = 0;    // header "time" field, unit unverified
+
+    // Latched from the newest "WSimu" area frame, if the device sends any.
+    std::optional<uint16_t> espe_error_status_;
+
+    // Snapshot for get_diagnostics(); refreshed by finish_scan().
+    Diagnostics latest_diag_;
+
+    ScanResult ready_result_;
+    bool       scan_ready_ = false;
+};
+
+} // namespace xlidar