Merging Atom/Orbital etc. about sisl HOT 1 OPEN

    def merge(self, other) -> Orbital:
        """ Merges two orbitals into one, with a preference of `self` """
        cls = self.__class__
        s = self.__getstate__()
        o = other.__getstate__()

        def inst_merge(typ, op):
            for k, v in s.items():
                if isinstance(v, typ):
                    s[k] = op(v, o[k])
        def key_merge(key, op):
            for k, v in s.items():
                if k == key:
                    s[k] = op(v, o[k])
        
        if isinstance(other, cls):
            inst_merge(float, max)
            # tag is defined for this orbital, no change
            key_merge("tag", lambda s, o: v if v else o)
            return cls(**s)

    def merge(self, other: Atom) -> Atom:
        """Merges two atoms into a single one, the calling atom will have precedence

        When merging there will be a couple of rules that will apply:

        1. When in doubt, the calling atom will have precedence.
        2. If the two atoms have the same `Z` value, they can be merged,
           otherwise, `self` will be returned *as-is*.
        3. The tag is only overwritten if not set.
        4. There is no way to decide which mass to choose. It will *always*
           take `self`.
        5. The orbitals requires explicit handling, the order will prefer
           `self`, but if there is more information in `other` those will
           be copied over.
        
        
        Parameters
        ----------
        other : Atom
            the other atom to merge into a single one
        """
        if self.Z != other.Z:
            return self
        mass = self.mass
        tag = self._tag or other._tag
        
        orbs = []
        for sorb in self:
            oorb = other[sorb.name()]
            if oorb is None:
                orbs.append(sorb)
                continue
            if isinstance(sorb, type(oorb)):
                # same type, now only check