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>

examples/lidar_app.cpp

@@ -1,6 +1,6 @@
 // Headless skeleton app: loads config.json, one reader thread per lidar.
-//   ./lidar_app [config.json]
-#include "lidarlib/lidarlib.hpp"
+//   ./lidar_app [config.json] [plugins_dir]
+#include "lidar_manager.hpp"
 #include <atomic>
 #include <csignal>
 #include <cstdio>
@@ -13,33 +13,31 @@ namespace {
 std::atomic<bool> g_running{true};
 void on_signal(int) { g_running = false; }
 
-void run_lidar(lidarlib::LidarConfig cfg) {
-    std::unique_ptr<lidarlib::Lidar> lidar = lidarlib::make_lidar(cfg);
-    lidarlib::ErrorCode err = lidar->open();
-    if (err != lidarlib::ErrorCode::Ok) {
-        fprintf(stderr, "[%s] khong mo duoc %s %s:%u (%s)\n",
-                cfg.name.c_str(), cfg.brand.c_str(), cfg.ip.c_str(), cfg.port,
-                lidarlib::to_string(err));
+void run_lidar(xlidar::LidarManager& manager, xlidar::DeviceConfig cfg) {
+    std::unique_ptr<xlidar::LidarDriverInterface> lidar = manager.create_lidar_device(cfg);
+    if (!lidar) return;
+
+    xlidar::ErrorCode err = lidar->open();
+    if (err != xlidar::ErrorCode::Ok) {
+        fprintf(stderr, "[%s] open failed %s (%s)\n",
+                cfg.name.c_str(), cfg.driver_id.c_str(), xlidar::to_string(err));
         return;
     }
-    printf("[%s] da mo %s %s:%u (model=%s, inverted=%d)\n",
-           cfg.name.c_str(), cfg.brand.c_str(), cfg.ip.c_str(), cfg.port,
-           cfg.model.c_str(), cfg.inverted);
+    printf("[%s] opened %s (model=%s, inverted=%d)\n",
+           cfg.name.c_str(), cfg.driver_id.c_str(), cfg.model.c_str(), cfg.inverted);
 
     while (g_running) {
-        lidarlib::ScanResult result;
+        xlidar::ScanResult result;
         if (!lidar->recv_scan(result, 1000)) continue;
 
-        const lidarlib::LaserScan& scan = result.scan;
-        const lidarlib::ExtraInfo& info = result.info;
-
-        printf("[%s] %zu diem | ts=%u ms | model=%s | err=0x%02X\n",
-               cfg.name.c_str(), scan.ranges.size(), scan.timestamp_ms,
-               info.detected_model.c_str(), info.error_status);
+        printf("[%s] %zu points | ts=%u ms | model=%s | diag=%s\n",
+               cfg.name.c_str(), result.scan.ranges.size(), result.scan.timestamp_ms,
+               result.info.detected_model.c_str(),
+               xlidar::to_string(lidar->get_diagnostics()).c_str());
     }
 
     lidar->close();
-    printf("[%s] da dong\n", cfg.name.c_str());
+    printf("[%s] closed\n", cfg.name.c_str());
 }
 
 } // namespace
@@ -48,23 +46,30 @@ int main(int argc, char** argv) {
     setvbuf(stdout, nullptr, _IOLBF, 0);
 
     const std::string config_path = (argc > 1) ? argv[1] : "config.json";
+    const std::string plugins_dir = (argc > 2) ? argv[2] : "plugins";
 
-    lidarlib::Config cfg = lidarlib::load_config(config_path);
-    lidarlib::save_config(config_path, cfg);  // ensure the file exists
+    xlidar::LidarManager manager(plugins_dir);
+    printf("%zu driver(s) available\n", manager.load_all_plugins());
+
+    xlidar::ManagerConfig cfg = xlidar::load_config(config_path);
+    xlidar::save_config(config_path, cfg);  // ensure the file exists (and migrate legacy keys)
 
     if (cfg.lidars.empty()) {
-        fprintf(stderr, "Khong co lidar nao trong %s\n", config_path.c_str());
+        fprintf(stderr, "no lidars in %s\n", config_path.c_str());
         return 1;
     }
 
     std::signal(SIGINT, on_signal);
     std::signal(SIGTERM, on_signal);
 
+    // One thread per device — instances are fully independent. The manager
+    // outlives every thread (join below), as the plugin contract requires.
     std::vector<std::thread> threads;
     threads.reserve(cfg.lidars.size());
-    for (const auto& lc : cfg.lidars) threads.emplace_back(run_lidar, lc);
+    for (const auto& lc : cfg.lidars)
+        threads.emplace_back(run_lidar, std::ref(manager), lc);
 
-    printf("Dang chay %zu lidar tu %s. Ctrl-C de dung.\n",
+    printf("running %zu lidar(s) from %s. Ctrl-C to stop.\n",
            cfg.lidars.size(), config_path.c_str());
     for (auto& t : threads) t.join();
     return 0;