Fix AT-URI parsing and knot routing in PR merge

Three bugs fixed:
1. parse_target_repo_info and parse_record_id expected 4 parts in a split
AT-URI but valid AT-URIs only have 3 parts after stripping the at://
prefix (in both pr.rs and issue.rs).
2. PR merge sent requests to the default tngl.sh gateway instead of the
actual knot hosting the repo, causing service auth token verification
to fail.
3. merge_pull used post_json but the merge endpoint returns an empty body
on success, causing a JSON parse error.

crates/tangled-api/src/client.rs

···
             commit_body,
         };
 
-        let _: serde_json::Value = self
-            .post_json("sh.tangled.repo.merge", &req, Some(&sa))
-            .await?;
-        Ok(())
+        self.post("sh.tangled.repo.merge", &req, Some(&sa))
+            .await
     }
 
     pub async fn merge_check(

crates/tangled-cli/src/commands/issue.rs

···
 fn parse_record_id<'a>(id: &'a str, default_did: &'a str) -> Result<(String, String)> {
     if let Some(rest) = id.strip_prefix("at://") {
         let parts: Vec<&str> = rest.split('/').collect();
-        if parts.len() >= 4 {
-            return Ok((parts[0].to_string(), parts[3].to_string()));
+        if parts.len() >= 3 {
+            return Ok((parts[0].to_string(), parts[2].to_string()));
         }
     }
     if let Some((did, rkey)) = id.split_once(':') {

crates/tangled-cli/src/commands/pr.rs

···
         .await?;
 
     // Parse target repo info
-    let (repo_did, repo_name) = parse_target_repo_info(&pull, &pds_client, &session).await?;
+    let (repo_did, repo_name, knot_host) = parse_target_repo_info(&pull, &pds_client, &session).await?;
 
     // Check if PR is part of a stack
     if let Some(stack_id) = &pull.stack_id {
···
             &repo_name,
             stack_id,
             &pds,
+            &knot_host,
         )
         .await?;
     } else {
         // Single PR merge (existing logic)
-        merge_single_pr(&session, &did, &rkey, &repo_did, &repo_name, &pds).await?;
+        merge_single_pr(&session, &did, &rkey, &repo_did, &repo_name, &pds, &knot_host).await?;
     }
 
     Ok(())
···
 fn parse_record_id<'a>(id: &'a str, default_did: &'a str) -> Result<(String, String)> {
     if let Some(rest) = id.strip_prefix("at://") {
         let parts: Vec<&str> = rest.split('/').collect();
-        if parts.len() >= 4 {
-            return Ok((parts[0].to_string(), parts[3].to_string()));
+        if parts.len() >= 3 {
+            return Ok((parts[0].to_string(), parts[2].to_string()));
         }
     }
     if let Some((did, rkey)) = id.split_once(':') {
···
     repo_did: &str,
     repo_name: &str,
     pds: &str,
+    knot_host: &str,
 ) -> Result<()> {
-    let api = tangled_api::TangledClient::default();
+    let api = tangled_api::TangledClient::new(knot_host);
     api.merge_pull(did, rkey, repo_did, repo_name, pds, &session.access_jwt)
         .await?;
 
···
     repo_name: &str,
     stack_id: &str,
     pds: &str,
+    knot_host: &str,
 ) -> Result<()> {
     // Step 1: Get full stack
     println!("🔍 Detecting stack...");
···
 
     // Step 3: Check for conflicts
     println!("✓ Checking for conflicts...");
-    let api = tangled_api::TangledClient::default();
+    let api = tangled_api::TangledClient::new(knot_host);
     let conflicts = check_stack_conflicts(
         &api,
         repo_did,
···
     pull: &tangled_api::Pull,
     pds_client: &tangled_api::TangledClient,
     session: &tangled_config::session::Session,
-) -> Result<(String, String)> {
+) -> Result<(String, String, String)> {
     let target_repo = &pull.target.repo;
     let parts: Vec<&str> = target_repo
         .strip_prefix("at://")
···
     let repo_did = parts[0].to_string();
     let repo_rkey = parts[2];
 
-    // Get repo name
+    // Get repo name and knot
     #[derive(serde::Deserialize)]
     struct Rec {
         name: String,
+        #[serde(default)]
+        knot: Option<String>,
     }
     #[derive(serde::Deserialize)]
     struct GetRes {
···
         )
         .await?;
 
-    Ok((repo_did, repo_rec.value.name))
+    let knot_host = match repo_rec.value.knot.as_deref() {
+        Some(k) if !k.is_empty() => format!("https://{}", k),
+        _ => "https://tngl.sh".to_string(),
+    };
+
+    Ok((repo_did, repo_rec.value.name, knot_host))
 }