### Godot version

4.1.1-stable

### System information

macOS 13.4.1 arm64

### Issue description

Implementing `_export_file`, `_export_begin` and `_export_end` in a gdextension export plugin does nothing.  
In engine we have this code:
```cpp
EditorExportPlatform::ExportNotifier::ExportNotifier(EditorExportPlatform &p_platform, const Ref<EditorExportPreset> &p_preset, bool p_debug, const String &p_path, int p_flags) {
	HashSet<String> features = p_platform.get_features(p_preset, p_debug);
	Vector<Ref<EditorExportPlugin>> export_plugins = EditorExport::get_singleton()->get_export_plugins();
	//initial export plugin callback
	for (int i = 0; i < export_plugins.size(); i++) {
		export_plugins.write[i]->set_export_preset(p_preset);
		if (export_plugins[i]->get_script_instance()) { //script based
			PackedStringArray features_psa;
			for (const String &feature : features) {
				features_psa.push_back(feature);
			}
			export_plugins.write[i]->_export_begin_script(features_psa, p_debug, p_path, p_flags);
		} else {
			export_plugins.write[i]->_export_begin(features, p_debug, p_path, p_flags);
		}
	}
}
```

We can see it will call `_export_begin_script` if a script instance is attached to the export plugin, otherwise it calls `_export_begin`. `_export_begin_script` does a `GDVIRTUAL_CALL` call, so it works within a script language. On another side `_export_begin` rely on classic cpp virtual call.
In the GdExtension case, we have no script instance attached, so we end up in classic cpp vtable case, but gdextensions does not use cpp vtable for inheritance. This ends up with no call to gdextension implementation.  

Currently, the only work around to make a gdextension export plugin work is to create a script proxy for it, here is my example.  
gdextension:
```cpp
namespace godot {
    class FmodEditorExportPlugin : public EditorExportPlugin {
        GDCLASS(FmodEditorExportPlugin, EditorExportPlugin)

    public:
        void _export_begin(const PackedStringArray &features, bool is_debug, const String &path, uint32_t flags) override;
        void _export_file(const String& path, const String& type, const PackedStringArray& features) override;

        String _get_name() const override;

        static void _bind_methods();

        FmodEditorExportPlugin() = default;
        ~FmodEditorExportPlugin() = default;
    };
}
```
Proxy script:
```gdscript
@tool
class_name FmodEditorExportPluginProxy
extends FmodEditorExportPlugin
```

I think we should always rely on `GDVIRTUAL_CALL` and avoid check on script instance, so that both script and gdextensions are handled.

### Steps to reproduce

Create a gdextension export plugin and add it using editor plugin.

### Minimal reproduction project

N/A
res = new_res;
							}
							break;
						}
					}
					
					if (res.is_valid() && !res->get_path().is_resource_file() && _export_customize_object(res.ptr(), customize_resources_plugins), true) {
						changed = true;
					}
				}
			} break;
			case Variant::DICTIONARY: {
				Dictionary d = v;
				if (_export_customize_dictionary(d, customize_resources_plugins)) {
					changed = true;
				}
			} break;
			case Variant::ARRAY: {
				Array a = v;
				if (_export_customize_array(a, customize_resources_plugins)) {
					changed = true;
				}
			} break;
			default: {
			}
		}
	}
	return changed;
}
bool EditorExportPlatform::_export_customize_object(Object *p_object, LocalVector<Ref<EditorExportPlugin>> &customize_resources_plugins) {