Add multiline quoted string tests for JavaScript and Rust

Following the C# test implementation, added equivalent test files:
- js/tests/MultilineQuotedString.test.js (4 tests)
- rust/tests/multiline_quoted_string_tests.rs (4 tests)

All tests verify multiline quoted string support:
- TestMultilineDoubleQuotedReference
- TestSimpleMultilineDoubleQuoted
- TestSimpleMultilineSingleQuoted
- TestMultilineQuotedAsId

All 84 JS tests and 84 Rust tests passing.

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

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

Author: konard

js/tests/MultilineQuotedString.test.js

@@ -0,0 +1,78 @@
+import { test, expect } from "bun:test";
+import { Parser } from "../src/Parser.js";
+
+const parser = new Parser();
+
+test("TestMultilineDoubleQuotedReference", () => {
+  const input = `(
+  "long
+string literal representing
+the reference"
+
+  'another
+long string literal
+as another reference'
+)`;
+  const result = parser.parse(input);
+
+  expect(result.length).toBeGreaterThan(0);
+  expect(result.length).toBe(1);
+
+  const link = result[0];
+  expect(link.id).toBe(null);
+  expect(link.values).toBeTruthy();
+  expect(link.values.length).toBe(2);
+
+  expect(link.values[0].id).toBe(`long
+string literal representing
+the reference`);
+
+  expect(link.values[1].id).toBe(`another
+long string literal
+as another reference`);
+});
+
+test("TestSimpleMultilineDoubleQuoted", () => {
+  const input = `("line1
+line2")`;
+  const result = parser.parse(input);
+
+  expect(result.length).toBeGreaterThan(0);
+  expect(result.length).toBe(1);
+
+  const link = result[0];
+  expect(link.id).toBe(null);
+  expect(link.values).toBeTruthy();
+  expect(link.values.length).toBe(1);
+  expect(link.values[0].id).toBe("line1\nline2");
+});
+
+test("TestSimpleMultilineSingleQuoted", () => {
+  const input = `('line1
+line2')`;
+  const result = parser.parse(input);
+
+  expect(result.length).toBeGreaterThan(0);
+  expect(result.length).toBe(1);
+
+  const link = result[0];
+  expect(link.id).toBe(null);
+  expect(link.values).toBeTruthy();
+  expect(link.values.length).toBe(1);
+  expect(link.values[0].id).toBe("line1\nline2");
+});
+
+test("TestMultilineQuotedAsId", () => {
+  const input = `("multi
+line
+id": value1 value2)`;
+  const result = parser.parse(input);
+
+  expect(result.length).toBeGreaterThan(0);
+  expect(result.length).toBe(1);
+
+  const link = result[0];
+  expect(link.id).toBe("multi\nline\nid");
+  expect(link.values).toBeTruthy();
+  expect(link.values.length).toBe(2);
+});

rust/tests/multiline_quoted_string_tests.rs

@@ -0,0 +1,103 @@
+use lino::{parse_lino, LiNo};
+
+#[test]
+fn test_multiline_double_quoted_reference() {
+    let input = r#"(
+  "long
+string literal representing
+the reference"
+
+  'another
+long string literal
+as another reference'
+)"#;
+    let result = parse_lino(input).unwrap();
+
+    if let LiNo::Link { id: outer_id, values: outer_values } = &result {
+        assert!(outer_id.is_none());
+        assert_eq!(outer_values.len(), 1);
+
+        if let LiNo::Link { id, values } = &outer_values[0] {
+            assert!(id.is_none());
+            assert_eq!(values.len(), 2);
+
+            if let LiNo::Ref(ref first_value) = values[0] {
+                assert_eq!(first_value, "long\nstring literal representing\nthe reference");
+            } else {
+                panic!("Expected first value to be a Ref");
+            }
+
+            if let LiNo::Ref(ref second_value) = values[1] {
+                assert_eq!(second_value, "another\nlong string literal\nas another reference");
+            } else {
+                panic!("Expected second value to be a Ref");
+            }
+        } else {
+            panic!("Expected first outer value to be a Link");
+        }
+    } else {
+        panic!("Expected result to be a Link");
+    }
+}
+
+#[test]
+fn test_simple_multiline_double_quoted() {
+    let input = r#"("line1
+line2")"#;
+    let result = parse_lino(input).unwrap();
+
+    if let LiNo::Link { id, values } = &result {
+        assert!(id.is_none());
+        assert_eq!(values.len(), 1);
+
+        if let LiNo::Ref(ref value) = values[0] {
+            assert_eq!(value, "line1\nline2");
+        } else {
+            panic!("Expected value to be a Ref");
+        }
+    } else {
+        panic!("Expected result to be a Link");
+    }
+}
+
+#[test]
+fn test_simple_multiline_single_quoted() {
+    let input = r#"('line1
+line2')"#;
+    let result = parse_lino(input).unwrap();
+
+    if let LiNo::Link { id, values } = &result {
+        assert!(id.is_none());
+        assert_eq!(values.len(), 1);
+
+        if let LiNo::Ref(ref value) = values[0] {
+            assert_eq!(value, "line1\nline2");
+        } else {
+            panic!("Expected value to be a Ref");
+        }
+    } else {
+        panic!("Expected result to be a Link");
+    }
+}
+
+#[test]
+fn test_multiline_quoted_as_id() {
+    let input = r#"("multi
+line
+id": value1 value2)"#;
+    let result = parse_lino(input).unwrap();
+
+    if let LiNo::Link { id: outer_id, values: outer_values } = &result {
+        assert!(outer_id.is_none());
+        assert_eq!(outer_values.len(), 1);
+
+        if let LiNo::Link { id, values } = &outer_values[0] {
+            assert_eq!(id.as_ref().unwrap(), "multi\nline\nid");
+            assert_eq!(values.len(), 2);
+        } else {
+            panic!("Expected first value to be a Link");
+        }
+    } else {
+        panic!("Expected result to be a Link");
+    }
+}