fix(ci): Address semver job issue (#1704)

# What does this PR do?

Adds a `git clone` fallback to `libdd-libunwind-sys/build.rs` for obtaining the libunwind source when the crate is built outside of a git repository.

The source acquisition logic is now structured as three steps:
1. If `libunwind/src` already exists (submodule checked out, or files copied in), do nothing.
2. If inside a git repo (`.git` exists), try `git submodule update --init --recursive`.
3. Otherwise, fall back to `git clone --depth 1` of the libunwind repository directly.

# Motivation

The `semver-check` CI job runs `cargo-semver-checks --baseline-rev origin/main`, which extracts the baseline source into a plain directory under `target/semver-checks/git-origin_main/<commit>/`. This directory has no `.git` — it's a raw file extraction, not a git clone or worktree.

When building the baseline version of `libdd-crashtracker`, cargo needs to compile its dependency `libdd-libunwind-sys`, which triggers `build.rs`. The previous implementation unconditionally ran `git submodule update --init` assuming it was inside a git repo, which failed with:

```
error: pathspec 'libdd-libunwind-sys/libunwind' did not match any file(s) known to git
```

This is not reproducible locally because a normal `git clone` properly initializes the submodule, and `build.rs` skips the git commands entirely when `libunwind/src` is already present.

# Additional Notes

- This fix must land on `main` before other branches that modify `libdd-crashtracker` can pass the `semver-check` CI job. This is because `cargo-semver-checks` uses the **baseline** (main) version of `build.rs` when building the baseline, not the branch's version.
- The libunwind repo URL and branch are extracted into constants (`LIBUNWIND_REPO`, `LIBUNWIND_BRANCH`) to keep them in sync with `.gitmodules`.
- The `git clone` fallback also covers other non-git contexts such as `cargo vendor` or any tool that extracts crate source without preserving git metadata.

# How to test the change?

```
git clone --no-checkout https://github.com/DataDog/libdatadog.git test-full
cd test-full
git checkout --detach origin/gyuheon0h/28.1.1
git submodule update --init --recursive -- libdd-libunwind-sys/libunwind
rm -rf target/semver-checks/
./scripts/semver-level.sh -v libdd-crashtracker main
```
   

Co-authored-by: gyuheon.oh <gyuheon.oh@datadoghq.com>

Author: gleocadie

libdd-libunwind-sys/build.rs

@@ -9,37 +9,91 @@ fn main() {
 #[cfg(target_os = "linux")]
 mod linux {
     use std::env;
-    use std::path::PathBuf;
+    use std::path::{Path, PathBuf};
+    use std::process::Command;
+
+    const LIBUNWIND_REPO: &str = "https://github.com/DataDog/libunwind.git";
+    const LIBUNWIND_BRANCH: &str = "kevin/v1.8.1-custom-2";
+
+    /// Try initializing the libunwind git submodule from the repo root.
+    /// Only works when running inside a git repository.
+    fn try_submodule_init(repo_root: &Path) -> bool {
+        if !repo_root.join(".git").exists() {
+            return false;
+        }
+        eprintln!("Initializing libunwind submodule...");
+        Command::new("git")
+            .args([
+                "submodule",
+                "update",
+                "--init",
+                "--recursive",
+                "--",
+                "libdd-libunwind-sys/libunwind",
+            ])
+            .current_dir(repo_root)
+            .status()
+            .map(|s| s.success())
+            .unwrap_or(false)
+    }
+
+    /// Clone the libunwind repository directly into `target_dir`.
+    /// Used as a fallback when not inside a git repo (e.g. cargo-semver-checks
+    /// extracts baseline source into a plain directory without .git).
+    fn clone_libunwind(target_dir: &Path) -> bool {
+        eprintln!("Cloning libunwind source (no git repo or submodule unavailable)...");
+        let _ = std::fs::remove_dir_all(target_dir);
+        Command::new("git")
+            .args([
+                "clone",
+                "--depth",
+                "1",
+                "--branch",
+                LIBUNWIND_BRANCH,
+                LIBUNWIND_REPO,
+                &target_dir.to_string_lossy(),
+            ])
+            .status()
+            .map(|s| s.success())
+            .unwrap_or(false)
+    }
+
+    fn ensure_libunwind_source(manifest_dir: &str, libunwind_dir: &Path) {
+        if libunwind_dir.join("src").exists() {
+            return;
+        }
+
+        let repo_root = Path::new(manifest_dir).parent().unwrap();
+
+        if try_submodule_init(repo_root) && libunwind_dir.join("src").exists() {
+            return;
+        }
+
+        // This can happen when running cargo-semver-checks
+        // because it extracts the baseline source into a plain directory without .git
+        if clone_libunwind(libunwind_dir) && libunwind_dir.join("src").exists() {
+            return;
+        }
+
+        panic!(
+            "Failed to obtain libunwind source at {}.\n\
+             Try manually:\n  \
+             git submodule update --init --recursive\n  \
+             or: git clone --branch {} {} {}",
+            libunwind_dir.display(),
+            LIBUNWIND_BRANCH,
+            LIBUNWIND_REPO,
+            libunwind_dir.display()
+        );
+    }
 
     pub(crate) fn main() {
         let out_dir = PathBuf::from(env::var("OUT_DIR").unwrap());
         let build_dir = out_dir.join("libunwind_build");
-        let manifest_dir = std::env::var("CARGO_MANIFEST_DIR").unwrap();
-        let libunwind_dir = std::path::Path::new(&manifest_dir).join("libunwind");
+        let manifest_dir = env::var("CARGO_MANIFEST_DIR").unwrap();
+        let libunwind_dir = Path::new(&manifest_dir).join("libunwind");
 
-        if !libunwind_dir.join("src").exists() {
-            eprintln!("Initializing libunwind submodule...");
-            let status = std::process::Command::new("git")
-                .args([
-                    "submodule",
-                    "update",
-                    "--init",
-                    "--recursive",
-                    "--",
-                    "libdd-libunwind-sys/libunwind",
-                ])
-                .current_dir(std::path::Path::new(&manifest_dir).parent().unwrap())
-                .status()
-                .expect("Failed to run git. Is git installed?");
-
-            if !status.success() || !libunwind_dir.join("src").exists() {
-                panic!(
-                    "Failed to initialize libunwind submodule at {}.\n\
-                     Try manually: git submodule update --init --recursive",
-                    libunwind_dir.display()
-                );
-            }
-        }
+        ensure_libunwind_source(&manifest_dir, &libunwind_dir);
 
         std::fs::create_dir_all(&build_dir).unwrap();