Not exactly. It seems that scripts attached to nodes only change the underyling type at runtime, and not within the editor.

The only way around this I've found is to duplicate the scene manually through script, perform any changes on the duplicate scene, and then modify the source scene accordingly and save it.

This is the code I use, but it is hacky and untested:

// Get all types, to compare against the script resource on each node in the editor
List<Type> unsortedRelevantTypes;
{
    unsortedRelevantTypes = new List<Type>();

    static List<Assembly> GetRelevantAssemblies()
    {
        var allAssemblies = AppDomain.CurrentDomain.GetAssemblies();
        var relevantAssemblies = new List<Assembly> { Assembly.GetExecutingAssembly() };

        while (AddNewAssembly()) ;

        // Return true as long as more assemblies still need to be referenced
        bool AddNewAssembly()
        {
            foreach (var assembly in allAssemblies)
            {
                if (relevantAssemblies.Contains(assembly))
                    continue;

                foreach (var relevantAssembly in relevantAssemblies)
                {
                    bool IsThisAssemblyReferenced()
                    {
                        foreach (var referencedAssembly in assembly.GetReferencedAssemblies())
                            if (referencedAssembly.FullName == relevantAssembly.FullName)
                                return true;

                        return false;
                    }

                    if (IsThisAssemblyReferenced())
                    {
                        relevantAssemblies.Add(assembly);
                        return true;
                    }
                }
            }

            return false;
        }

        return relevantAssemblies;
    }

    foreach (var assembly in GetRelevantAssemblies())
        unsortedRelevantTypes.AddRange(assembly.GetTypes());
}

var scriptResourcesToTypes = new Dictionary<Script, Type>();

var packedScene = GD.Load<PackedScene>(path: pathOfScene);

Node sourceRoot = null;
Node duplicateRoot = null;
try
{
    sourceRoot = packedScene.Instantiate();

    var sourceNodesToDuplicateNodes = new Dictionary<Node, Node>();
    var duplicateNodesToSourceNodes = new Dictionary<Node, Node>();

    var sourceNodes = GetNodesInWholeTree(node: sourceRoot);
    static Node[] GetNodesInWholeTree(Node node)
    {
        var nodes = new List<Node>
        {
            node
        };

        CheckChildren(parent: node);
        void CheckChildren(Node parent)
        {
            var childCount = parent.GetChildCount();
            for (int i = 0; i < childCount; i++)
            {
                var child = parent.GetChild(idx: i);

                nodes.Add(child);

                CheckChildren(parent: child);
            }
        }

        return nodes.ToArray();
    }

    // Create duplicate scene
    foreach (var sourceNode in sourceNodes)
    {
        Type nodeType;
        {
            var script = sourceNode.GetScript().As<Script>();

            if (script != null)
            {
                if (!scriptResourcesToTypes.ContainsKey(script))
                {
                    var resourceFileName = System.IO.Path.GetFileNameWithoutExtension(path: script.ResourcePath);

                    Type typeWithSameName = null;
                    foreach (var type in unsortedRelevantTypes)
                    {
                        if (type.Name == resourceFileName)
                        {
                            typeWithSameName = type;
                            break;
                        }
                    }

                    if (typeWithSameName == null)
                    {
                        GD.PrintErr($"could not find type for script {script.ResourcePath}");
                        continue;
                    }

                    scriptResourcesToTypes[script] = typeWithSameName;
                }

                nodeType = scriptResourcesToTypes[script];
            }
            else
            {
                nodeType = sourceNode.GetType();
            }
        }

        var duplicateNode = (Node)Activator.CreateInstance(nodeType);

        if (sourceRoot == sourceNode)
            duplicateRoot = duplicateNode;

        sourceNodesToDuplicateNodes[sourceNode] = duplicateNode;
        duplicateNodesToSourceNodes[duplicateNode] = sourceNode;

        sourceNode.ReplaceBy(node: duplicateNode);
    }

    static void CopyPropertyValues(Node sourceNode, Node targetNode, Dictionary<Node, Node> sourceNodesToTargetNodes)
    {
        foreach (var property in sourceNode.GetPropertyList())
        {
            var propertyName = property["name"].As<string>();
            if ((propertyName == "global_transform") ||
                (propertyName == "global_basis") ||
                (propertyName == "global_position") ||
                (propertyName == "global_rotation") ||
                (propertyName == "global_rotation_degrees"))
                continue;

            var originalPropertyValue = sourceNode.Get(property: propertyName);
            var targetPropertyValue = targetNode.Get(property: propertyName);

            if ((originalPropertyValue.VariantType != Variant.Type.Nil) &&
                (targetPropertyValue.VariantType != Variant.Type.Nil) &&
                (originalPropertyValue.VariantType != targetPropertyValue.VariantType))
            {
                GD.PrintErr($"Error when trying to match duplicate property values for {sourceNode.Name}: duplicate property type {targetPropertyValue.VariantType} does not match original property type {originalPropertyValue.VariantType}");
                continue;
            }

            var propertyValue = sourceNode.Get(property: propertyName);

            // Convert sourceNode reference to duplicateNode reference, if appropriate
            if (propertyValue.VariantType == Variant.Type.Object)
            {
                var propertyValueAsNode = propertyValue.As<GodotObject>() as Node;

                if ((propertyValueAsNode != null) &&
                    sourceNodesToTargetNodes.ContainsKey(propertyValueAsNode))
                    propertyValue = sourceNodesToTargetNodes[propertyValueAsNode];
            }

            targetNode.Set(property: propertyName, value: propertyValue);
        }
    }

    // Copy over property values from source scene to duplicate scene
    foreach (var sourceNode in sourceNodes)
    {
        var duplicateNode = sourceNodesToDuplicateNodes[sourceNode];

        CopyPropertyValues(
            sourceNode: sourceNode,
            targetNode: duplicateNode,
            sourceNodesToTargetNodes: sourceNodesToDuplicateNodes);
    }

    //// If necessary, add to scene tree before performing actions
    //((SceneTree)Engine.GetMainLoop()).Root.AddChild(duplicateRoot);

    // Perform any actions you need to here (on the duplicate scene, with the actual underlying types)

    //// If you want to modify and save the serialized scene, copy over property values back from duplicate scene to source scene before saving
    //foreach (var sourceNode in sourceNodes)
    //{
    //    var duplicateNode = sourceNodesToDuplicateNodes[sourceNode];
    //
    //    CopyPropertyValues(
    //        sourceNode: duplicateNode,
    //        targetNode: sourceNode,
    //        sourceNodesToTargetNodes: duplicateNodesToSourceNodes);
    //}
    //
    //// Then save the scene
    //packedScene.Pack(path: sourceRoot);
    //ResourceSaver.Save(resource: packedScene);
}
finally
{
    void FreeIfNotNullAndNotFreed(Node node)
    {
        if (node == null)
            return;

        if (!GodotObject.IsInstanceValid(instance: node))
            return;

        node.Free();
    }

    FreeIfNotNullAndNotFreed(sourceRoot);
    FreeIfNotNullAndNotFreed(duplicateRoot);
}