feat: enable support for overlapping type and constructor names in logic schema definitions

Author: iislucas

animated-transformer/.agents/skills/relational_linear_logic_syntax/SKILL.md

@@ -39,17 +39,12 @@ type typeName = variant1 | variant2(...) | variant3;
   type list<'a> = nil | cons(head: 'a, tail: list<'a>);
   ```
 
-### CRITICAL RULE: Disjoint Type and Constructor Namespaces
+### Type and Constructor Namespaces
 
 In this logic engine, all type names and constructor names are stored in a single flat registry (`Context.data.literals`).
 
-- **No Name Overlapping:** A type name and a constructor name **must never be identical**.
-- **The Namespace Clash:** Declaring `type animal = animal(kind: species);` causes the constructor name `animal` to overwrite the type name `animal` in the literal registry. This results in runtime type-checking failures like:
-  `TypeError: Cannot convert undefined or null to object` in `validateAddedTypes`.
-- **Solution:** Always prefix or distinguish constructor names from their return types (e.g., use `makeAnimal` or `animalKind` as the constructor for the `animal` type):
-  ```linear-logic
-  type animal = makeAnimal(kind: species);
-  ```
+- **Overlapping Names are Supported:** A type name and a constructor name can safely be identical.
+- **Cleaner Schemas:** Declaring `type animal = animal(kind: species);` is fully supported and recommended when a type has a single primary constructor, allowing cleaner and more natural schemas.
 
 ---
 
@@ -59,7 +54,7 @@ The type system does not support implicit subtyping or inheritance.
 
 - **Lifting/Wrapping Pattern:** To include a value of a distinct type (like `animal`) inside a broader union type (like `item`), you must define an explicit wrapper constructor to "lift" the value:
   ```linear-logic
-  type animal = makeAnimal(kind: species);
+  type animal = animal(kind: species);
   type item = animalVal(who: animal) | flower | rock | tree;
   ```
 - **Compile-Time Enforcement:** By keeping `animal` as a separate type, you can strictly type action/state parameters to only accept animals at compile-time:
@@ -75,7 +70,7 @@ The type system does not support implicit subtyping or inheritance.
 Constant values or compound terms can be declared using the `let` keyword:
 
 ```linear-logic
-let myCat = makeAnimal(cat);
+let myCat = animal(cat);
 let initialStage = active(flower);
 ```
 
@@ -104,7 +99,7 @@ fun isFlower(flower) = true
 Actions represent state transitions in the linear logic story. They consume resources on the left-hand side (LHS) of the `-o` operator and produce resources on the right-hand side (RHS).
 
 ```linear-logic
-action monkeySquish: { ?j: jumpedOver(makeAnimal(monkey), flower) } -o { ?s: squished(makeAnimal(monkey), flower) };
+action monkeySquish: { ?j: jumpedOver(animal(monkey), flower) } -o { ?s: squished(animal(monkey), flower) };
 ```
 
 - **LHS (`{ ... }`):** The linear resources required to trigger the action.

animated-transformer/src/app/logic-explorer/logic-docs.component.html

@@ -107,15 +107,14 @@ <h2>2. Algebraic Data Types (ADTs)</h2>
             <pre class="code-body" [innerHTML]="getHighlightHtml(listTypeCode)"></pre>
           </div>
 
-          <div class="callout warning">
-            <mat-icon>warning</mat-icon>
+          <div class="callout info">
+            <mat-icon>info</mat-icon>
             <div class="callout-content">
-              <strong>CRITICAL Namespace Rule:</strong> 
-              All type names and constructor names are stored in a single flat registry. Therefore, 
-              <strong>a type name and constructor name must never overlap</strong>. 
-              Declaring <code>type animal = animal(kind: species)</code> causes the constructor to overwrite 
-              the type, yielding type-checking failures at runtime. Always prefix or vary the constructor: 
-              <code>type animal = makeAnimal(kind: species)</code>.
+              <strong>Namespace & Overlapping Names:</strong> 
+              Type names and constructor names are stored in a single flat registry, but they 
+              <strong>can safely overlap</strong>. Declaring <code>type animal = animal(kind: species)</code> 
+              is fully supported and allows the constructor to share the name with its type, providing 
+              a cleaner and more natural syntax.
             </div>
           </div>
         </div>