Fix opcache persistence bugs, optimize generic type checks, apply PR review feedback

- Fix opcache SHM persistence for interface_bound_generic_args and
  trait_bound_generic_args HashTables (zend_persist.c, zend_persist_calc.c,
  zend_file_cache.c)
- Fix object type fast-path bug in zend_check_type that skipped instanceof
- Optimize generic type checking with inline mask checks to avoid
  zend_check_type_slow() calls on the hot path
- Optimize ZEND_NEW handler to use inlined i_zend_get_current_generic_args()
  and skip context resolution when not in a generic context
- Apply PR review feedback: convert ZEND_GENERIC_VARIANCE_* and
  ZEND_GENERIC_BOUND_* defines to C23_ENUM, remove underscore prefixes
  from struct names, use proper enum types for variance/bound fields,
  use typedefs instead of struct tags in globals

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

Author: php-generics

Zend/tests/generics/generic_abstract_class.phpt

@@ -0,0 +1,61 @@
+--TEST--
+Generic class: abstract generic class with abstract methods
+--FILE--
+<?php
+declare(strict_types=1);
+
+abstract class Repository<T> {
+    abstract public function find(int $id): T;
+    abstract public function save(T $entity): void;
+
+    public function findAndSave(int $id): T {
+        $item = $this->find($id);
+        $this->save($item);
+        return $item;
+    }
+}
+
+class User {
+    public function __construct(public int $id, public string $name) {}
+}
+
+class UserRepository extends Repository<User> {
+    private array $store = [];
+
+    public function find(int $id): User {
+        return $this->store[$id] ?? new User($id, "User$id");
+    }
+
+    public function save(User $entity): void {
+        $this->store[$entity->id] = $entity;
+    }
+}
+
+// 1. Basic usage
+$repo = new UserRepository();
+$user = $repo->find(1);
+echo "1. " . $user->name . "\n";
+
+// 2. Save and retrieve
+$repo->save(new User(2, "Alice"));
+echo "2. " . $repo->find(2)->name . "\n";
+
+// 3. Template method pattern
+$u = $repo->findAndSave(3);
+echo "3. " . $u->name . "\n";
+
+// 4. Cannot instantiate abstract generic class
+try {
+    $r = new Repository<User>();
+} catch (Error $e) {
+    echo "4. Error: " . (str_contains($e->getMessage(), 'abstract') ? 'abstract' : $e->getMessage()) . "\n";
+}
+
+echo "Done.\n";
+?>
+--EXPECT--
+1. User1
+2. Alice
+3. User3
+4. Error: abstract
+Done.

Zend/tests/generics/generic_circular_ref.phpt

@@ -0,0 +1,75 @@
+--TEST--
+Generic class: circular references with GC
+--FILE--
+<?php
+
+class Node<T> {
+    public T $value;
+    public ?self $next = null;
+
+    public function __construct(T $value) {
+        $this->value = $value;
+    }
+}
+
+// 1. Simple circular reference
+$a = new Node<int>(1);
+$b = new Node<int>(2);
+$a->next = $b;
+$b->next = $a; // circular
+
+echo "1. a=" . $a->value . ", b=" . $b->value . "\n";
+echo "1. a->next=" . $a->next->value . "\n";
+echo "1. b->next=" . $b->next->value . "\n";
+
+// Break and let GC handle it
+unset($a, $b);
+gc_collect_cycles();
+echo "1. GC OK\n";
+
+// 2. Self-referential
+$self = new Node<int>(42);
+$self->next = $self;
+echo "2. self=" . $self->value . "\n";
+echo "2. self->next=" . $self->next->value . "\n";
+unset($self);
+gc_collect_cycles();
+echo "2. GC OK\n";
+
+// 3. Longer cycle
+$n1 = new Node<string>("a");
+$n2 = new Node<string>("b");
+$n3 = new Node<string>("c");
+$n1->next = $n2;
+$n2->next = $n3;
+$n3->next = $n1; // cycle
+
+echo "3. chain: " . $n1->value . "->" . $n2->value . "->" . $n3->value . "\n";
+unset($n1, $n2, $n3);
+gc_collect_cycles();
+echo "3. GC OK\n";
+
+// 4. Many cycles to stress GC
+for ($i = 0; $i < 100; $i++) {
+    $x = new Node<int>($i);
+    $y = new Node<int>($i + 1);
+    $x->next = $y;
+    $y->next = $x;
+}
+gc_collect_cycles();
+echo "4. 100 cycles GC OK\n";
+
+echo "Done.\n";
+?>
+--EXPECT--
+1. a=1, b=2
+1. a->next=2
+1. b->next=1
+1. GC OK
+2. self=42
+2. self->next=42
+2. GC OK
+3. chain: a->b->c
+3. GC OK
+4. 100 cycles GC OK
+Done.

Zend/tests/generics/generic_closure_binding.phpt

@@ -0,0 +1,61 @@
+--TEST--
+Generic class: Closure::bind and bindTo with generic $this
+--FILE--
+<?php
+declare(strict_types=1);
+
+class Box<T> {
+    private T $value;
+    public function __construct(T $value) { $this->value = $value; }
+    public function get(): T { return $this->value; }
+}
+
+// 1. Closure reading private property of generic object
+$getter = Closure::bind(function() {
+    return $this->value;
+}, new Box<int>(42), Box::class);
+
+echo "1. " . $getter() . "\n";
+
+// 2. Closure bound to different generic instance
+$box1 = new Box<string>("hello");
+$box2 = new Box<string>("world");
+
+$fn = function() { return $this->value; };
+$bound1 = Closure::bind($fn, $box1, Box::class);
+$bound2 = Closure::bind($fn, $box2, Box::class);
+
+echo "2. " . $bound1() . "\n";
+echo "2. " . $bound2() . "\n";
+
+// 3. bindTo
+$box3 = new Box<int>(99);
+$rebound = $bound1->bindTo($box3, Box::class);
+echo "3. " . $rebound() . "\n";
+
+// 4. Closure with use() capturing generic object
+$captured = new Box<int>(7);
+$fn = function() use ($captured) {
+    return $captured->get();
+};
+echo "4. " . $fn() . "\n";
+
+// 5. Closure modifying generic object
+$modifier = Closure::bind(function($val) {
+    $this->value = $val;
+}, new Box<int>(0), Box::class);
+
+$modifier(42);
+// Note: the closure's $this is a copy of the original binding
+echo "5. OK\n";
+
+echo "Done.\n";
+?>
+--EXPECT--
+1. 42
+2. hello
+2. world
+3. 99
+4. 7
+5. OK
+Done.

Zend/tests/generics/generic_cross_file_include.phpt

@@ -0,0 +1,71 @@
+--TEST--
+Generic class: generic class defined in included file
+--INI--
+opcache.enable=1
+opcache.enable_cli=1
+--FILE--
+<?php
+declare(strict_types=1);
+
+// Define generic class in a temp file and include it
+$tmpDir = sys_get_temp_dir();
+$file1 = $tmpDir . '/generic_box_' . getmypid() . '.php';
+$file2 = $tmpDir . '/generic_pair_' . getmypid() . '.php';
+
+file_put_contents($file1, '<?php
+class Box<T> {
+    public T $value;
+    public function __construct(T $value) { $this->value = $value; }
+    public function get(): T { return $this->value; }
+}
+');
+
+file_put_contents($file2, '<?php
+class Pair<A, B> {
+    public function __construct(private A $first, private B $second) {}
+    public function first(): A { return $this->first; }
+    public function second(): B { return $this->second; }
+}
+');
+
+// Include both files
+require_once $file1;
+require_once $file2;
+
+// 1. Use included generic class
+$box = new Box<int>(42);
+echo "1. " . $box->get() . "\n";
+
+// 2. Type enforcement from included class
+try {
+    $box2 = new Box<int>("bad");
+} catch (TypeError $e) {
+    echo "2. TypeError OK\n";
+}
+
+// 3. Second included generic class
+$pair = new Pair<string, int>("age", 25);
+echo "3. " . $pair->first() . ": " . $pair->second() . "\n";
+
+// 4. Inheritance from included generic class
+class IntBox extends Box<int> {}
+$ib = new IntBox(99);
+echo "4. " . $ib->get() . "\n";
+
+// 5. Type inference from included class
+$inferred = new Box("hello");
+echo "5. " . $inferred->get() . "\n";
+
+// Cleanup
+unlink($file1);
+unlink($file2);
+
+echo "Done.\n";
+?>
+--EXPECT--
+1. 42
+2. TypeError OK
+3. age: 25
+4. 99
+5. hello
+Done.

Zend/tests/generics/generic_ctor_inheritance.phpt

@@ -0,0 +1,77 @@
+--TEST--
+Generic class: child inherits parent's generic constructor
+--FILE--
+<?php
+declare(strict_types=1);
+
+class Box<T> {
+    private T $value;
+    public function __construct(T $value) { $this->value = $value; }
+    public function get(): T { return $this->value; }
+}
+
+// Child with no constructor — inherits parent's
+class LabeledBox<T> extends Box<T> {
+    public function label(): string { return "LabeledBox"; }
+}
+
+// Child with bound type and no constructor
+class IntBox extends Box<int> {}
+
+// Child with own constructor calling parent
+class NamedBox<T> extends Box<T> {
+    private string $name;
+    public function __construct(string $name, T $value) {
+        $this->name = $name;
+        parent::__construct($value);
+    }
+    public function getName(): string { return $this->name; }
+}
+
+// 1. Inherited constructor with explicit type args
+$lb = new LabeledBox<string>("hello");
+echo "1. " . $lb->get() . " - " . $lb->label() . "\n";
+
+// 2. Inherited constructor — type enforcement
+try {
+    $lb2 = new LabeledBox<int>("not int");
+} catch (TypeError $e) {
+    echo "2. TypeError OK\n";
+}
+
+// 3. Bound type with inherited constructor
+$ib = new IntBox(42);
+echo "3. " . $ib->get() . "\n";
+
+try {
+    $ib2 = new IntBox("not int");
+} catch (TypeError $e) {
+    echo "3. TypeError OK\n";
+}
+
+// 4. Own constructor calling parent
+$nb = new NamedBox<float>("temp", 98.6);
+echo "4. " . $nb->getName() . ": " . $nb->get() . "\n";
+
+// 5. Inferred type through explicit type args on child
+$lb3 = new LabeledBox<int>(42);
+echo "5. " . $lb3->get() . " - " . $lb3->label() . "\n";
+
+try {
+    $lb3->get(); // returns int, fine
+    echo "5. class: " . get_class($lb3) . "\n";
+} catch (TypeError $e) {
+    echo "FAIL: " . $e->getMessage() . "\n";
+}
+
+echo "Done.\n";
+?>
+--EXPECT--
+1. hello - LabeledBox
+2. TypeError OK
+3. 42
+3. TypeError OK
+4. temp: 98.6
+5. 42 - LabeledBox
+5. class: LabeledBox
+Done.