Add links-notation API experiment

Replace old experiment files with a cleaner example demonstrating how to use
the links-notation crate API for parsing LiNo format (doublets, triplets,
named links, and multiple links).

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: konard

experiments/Cargo.toml

@@ -0,0 +1,12 @@
+[package]
+name = "lino-api-test"
+version = "0.1.0"
+edition = "2021"
+publish = false
+
+[dependencies]
+links-notation = "0.13.0"
+
+# Note: doublets crate requires nightly Rust due to unstable features
+# Uncomment to test with nightly: rustup run nightly cargo build
+# doublets = "0.1.0-pre"

experiments/README.md

@@ -0,0 +1,31 @@
+# Experiments
+
+This folder contains experiments for testing Links Theory dependencies.
+
+## LiNo API Test (`src/main.rs`)
+
+Demonstrates how to use the `links-notation` crate to parse Links Notation (LiNo) format:
+
+- Simple doublet format: `(1 2)`
+- Triplet format: `(A connects B)`
+- Named links: `(link1: 1 2)`
+- Multiple links: `(1 2) (2 3) (3 1)`
+
+### Running
+
+```bash
+cd experiments
+cargo run
+```
+
+## Notes on `doublets` crate
+
+The `doublets` crate (from [linksplatform/doublets-rs](https://github.com/linksplatform/doublets-rs)) provides persistent storage for doublet-links but requires nightly Rust due to unstable features like `step_trait` and `trait_alias`.
+
+To experiment with it, use nightly Rust:
+
+```bash
+rustup run nightly cargo build
+```
+
+The main `network-isomorphism-solver` library uses stable Rust and in-memory storage for broader compatibility.

experiments/debug_xor.rs

@@ -0,0 +1,75 @@
+use links_notation::{parse_lino, LiNo};
+
+fn main() {
+    // Test parsing simple links notation
+    println!("Testing links-notation crate...\n");
+
+    // Simple doublet format
+    let input = "(1 2)";
+    println!("Input: {}", input);
+    match parse_lino(input) {
+        Ok(result) => {
+            println!("Parsed: {:?}", result);
+            explore_lino(&result);
+        }
+        Err(e) => {
+            println!("Error: {:?}", e);
+        }
+    }
+
+    // Triplet format
+    let input2 = "(A connects B)";
+    println!("\nInput: {}", input2);
+    match parse_lino(input2) {
+        Ok(result) => {
+            println!("Parsed: {:?}", result);
+            explore_lino(&result);
+        }
+        Err(e) => {
+            println!("Error: {:?}", e);
+        }
+    }
+
+    // Named link
+    let input3 = "(link1: 1 2)";
+    println!("\nInput: {}", input3);
+    match parse_lino(input3) {
+        Ok(result) => {
+            println!("Parsed: {:?}", result);
+            explore_lino(&result);
+        }
+        Err(e) => {
+            println!("Error: {:?}", e);
+        }
+    }
+
+    // Multiple links
+    let input4 = "(1 2) (2 3) (3 1)";
+    println!("\nInput: {}", input4);
+    match parse_lino(input4) {
+        Ok(result) => {
+            println!("Parsed: {:?}", result);
+            explore_lino(&result);
+        }
+        Err(e) => {
+            println!("Error: {:?}", e);
+        }
+    }
+}
+
+fn explore_lino(lino: &LiNo<String>) {
+    println!("  is_link: {}", lino.is_link());
+    println!("  is_ref: {}", lino.is_ref());
+
+    match lino {
+        LiNo::Ref(r) => {
+            println!("  -> Ref: {:?}", r);
+        }
+        LiNo::Link { id, values } => {
+            println!("  -> Link id: {:?}, values count: {}", id, values.len());
+            for (i, val) in values.iter().enumerate() {
+                println!("     value[{}]: {:?}", i, val);
+            }
+        }
+    }
+}