Explorer: Add virtual destructor support (#2695)

### Features

* Add virtual `destructor`s support (Closes #2521)
* Check virtual override for virtual destructors
* Error if attempting to `Delete` a class that does not have virtual destructors from a base class pointer 

### Implementation

* Update parser to support virtual override introducers for destructors
* Check virtual override for class destructor and add to class vtable if necessary
* Add corresponding tests

### Notes

Contrary to initial implementation, this implementation leverages the `Address` structure and implements a new `Address::DowncastedAddress()` method to get address from child most class from a base class address. This avoids the need to use `GetAllocationId` and its issues when it comes to having multiple values for an `AllocationId`.

### Next work

Following this PR, we need to:

* Check when using `Delete` that the class was allocated with `New` (WIP)
* Drop the old `GetAllocationId(Value*)` in favor of a better system (WIP)

explorer/testdata/destructor/fail_delete_base_without_virtual_destructor.carbon

@@ -0,0 +1,29 @@
+// Part of the Carbon Language project, under the Apache License v2.0 with LLVM
+// Exceptions. See /LICENSE for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+// AUTOUPDATE
+// RUN: %{not} %{explorer-run}
+// RUN: %{not} %{explorer-run-trace}
+// CHECK:STDERR: RUNTIME ERROR: {{.*}}/explorer/data/prelude.carbon:{{.*}}: Deallocating a derived class from base class pointer requires a virtual destructor
+
+package ExplorerTest api;
+
+
+base class A{
+    destructor[self: Self]{}
+}
+
+class B extends A {
+    fn Create() -> Self {
+        return {.base={}};
+    }
+    destructor[self: Self]{}
+}
+
+fn Main() -> i32 {
+  var pb: B* = heap.New(B.Create());
+  var pa: A* = pb;
+  heap.Delete(pa);
+  return 0;
+}

explorer/testdata/destructor/fail_override_abstract.carbon

@@ -0,0 +1,19 @@
+// Part of the Carbon Language project, under the Apache License v2.0 with LLVM
+// Exceptions. See /LICENSE for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+// AUTOUPDATE
+// RUN: %{not} %{explorer-run}
+// RUN: %{not} %{explorer-run-trace}
+
+package ExplorerTest api;
+
+
+base class A {
+    // CHECK:STDERR: SYNTAX ERROR: {{.*}}/explorer/testdata/destructor/fail_override_abstract.carbon:[[@LINE+1]]: syntax error, unexpected DESTRUCTOR, expecting CLASS
+    abstract destructor[self: Self]{}
+}
+
+fn Main() -> i32 {
+  return 0;
+}

explorer/testdata/destructor/fail_override_impl_none.carbon

@@ -0,0 +1,19 @@
+// Part of the Carbon Language project, under the Apache License v2.0 with LLVM
+// Exceptions. See /LICENSE for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+// AUTOUPDATE
+// RUN: %{not} %{explorer-run}
+// RUN: %{not} %{explorer-run-trace}
+
+package ExplorerTest api;
+
+
+base class A {
+    // CHECK:STDERR: COMPILATION ERROR: {{.*}}/explorer/testdata/destructor/fail_override_impl_none.carbon:[[@LINE+1]]: Error declaring destructor for `A`: cannot override a destructor that is not declared `virtual` in base class.
+    impl destructor[self: Self]{}
+}
+
+fn Main() -> i32 {
+  return 0;
+}

explorer/testdata/destructor/fail_override_virtual_virtual.carbon

@@ -0,0 +1,23 @@
+// Part of the Carbon Language project, under the Apache License v2.0 with LLVM
+// Exceptions. See /LICENSE for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+// AUTOUPDATE
+// RUN: %{not} %{explorer-run}
+// RUN: %{not} %{explorer-run-trace}
+
+package ExplorerTest api;
+
+
+base class A {
+    virtual destructor[self: Self]{}
+}
+
+class B extends A {
+    // CHECK:STDERR: COMPILATION ERROR: {{.*}}/explorer/testdata/destructor/fail_override_virtual_virtual.carbon:[[@LINE+1]]: Error declaring destructor for `B`: use `impl` to implement virtual destructor in child class.
+    virtual destructor[self: Self]{}
+}
+
+fn Main() -> i32 {
+  return 0;
+}

explorer/testdata/destructor/virtual_destructor.carbon

@@ -0,0 +1,51 @@
+// Part of the Carbon Language project, under the Apache License v2.0 with LLVM
+// Exceptions. See /LICENSE for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+// AUTOUPDATE
+// RUN: %{explorer-run}
+// RUN: %{explorer-run-trace}
+// CHECK:STDOUT: Allocate C
+// CHECK:STDOUT: DESTRUCTOR C
+// CHECK:STDOUT: DESTRUCTOR B
+// CHECK:STDOUT: DESTRUCTOR A
+// CHECK:STDOUT: Delete C from A*
+// CHECK:STDOUT: DESTRUCTOR C
+// CHECK:STDOUT: DESTRUCTOR B
+// CHECK:STDOUT: DESTRUCTOR A
+// CHECK:STDOUT: result: 0
+
+package ExplorerTest api;
+
+
+base class A {
+    virtual destructor[self: Self] {
+        Print("DESTRUCTOR A");
+    }
+}
+
+base class B extends A {
+    impl destructor[self: Self] {
+        Print("DESTRUCTOR B");
+    }
+}
+
+class C extends B {
+    fn Create() -> Self{
+        return {.base={.base={}}};
+    }
+    impl destructor[self: Self] {
+        Print("DESTRUCTOR C");
+    }
+}
+
+fn Main() -> i32 {
+  Print("Allocate C");
+  var pc: C* = heap.New(C.Create());
+  var pa: A* = pc;
+
+  Print("Delete C from A*");
+  heap.Delete(pa);
+
+  return 0;
+}

explorer/testdata/destructor/virtual_destructor_nested.carbon

@@ -0,0 +1,67 @@
+// Part of the Carbon Language project, under the Apache License v2.0 with LLVM
+// Exceptions. See /LICENSE for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+// AUTOUPDATE
+// RUN: %{explorer-run}
+// RUN: %{explorer-run-trace}
+// CHECK:STDOUT: Allocate D
+// CHECK:STDOUT: DESTRUCTOR B
+// CHECK:STDOUT: DESTRUCTOR A
+// CHECK:STDOUT: DESTRUCTOR D
+// CHECK:STDOUT: DESTRUCTOR C
+// CHECK:STDOUT: Delete B from A*
+// CHECK:STDOUT: DESTRUCTOR B
+// CHECK:STDOUT: DESTRUCTOR A
+// CHECK:STDOUT: Delete D from C*
+// CHECK:STDOUT: DESTRUCTOR D
+// CHECK:STDOUT: DESTRUCTOR C
+// CHECK:STDOUT: result: 0
+
+package ExplorerTest api;
+
+
+base class A {
+    virtual destructor[self: Self] {
+        Print("DESTRUCTOR A");
+    }
+}
+
+class B extends A {
+    fn Create() -> Self{
+        return {.base={}};
+    }
+    impl destructor[self: Self] {
+        Print("DESTRUCTOR B");
+    }
+}
+
+base class C {
+    virtual destructor[self: Self] {
+        Print("DESTRUCTOR C");
+    }
+}
+
+class D extends C {
+    fn Create() -> Self{
+        return {.base={}, .d_pa=heap.New(B.Create())};
+    }
+    impl destructor[self: Self] {
+        Print("DESTRUCTOR D");
+    }
+    var d_pa: A*;
+}
+
+fn Main() -> i32 {
+  Print("Allocate D");
+  var pd: D* = heap.New(D.Create());
+  var pc: C* = pd;
+
+  Print("Delete B from A*");
+  heap.Delete(pd->d_pa);
+
+  Print("Delete D from C*");
+  heap.Delete(pc);
+
+  return 0;
+}