Why does the contracts wizard ERC721 derive both ERC721 and ERC721 votes?

Smart Contracts
1

The contracts wizard derives the following code for ERC721 and when I check the Votes option:

contract MyToken is ERC721, EIP712, ERC721Votes {
    constructor() ERC721("MyToken", "MTK") EIP712("MyToken", "1") {}

    // The following functions are overrides required by Solidity.

    function _afterTokenTransfer(address from, address to, uint256 tokenId)
        internal
        override(ERC721, ERC721Votes)
    {
        super._afterTokenTransfer(from, to, tokenId);
    }
}

Why does the contract inherit from both ERC721 AND ERC721Votes? Since ERC721Votes in turn inherits from ERC721? Doesn't this essentially inherit from ERC721.sol twice? Wouldn't we be just fine if I just inherited from ERC721Votes, receiving the votes functionality on top of the vanilla ERC721 functionality? I removed the inheritance from ERC721 and as far as I can tell, it works just fine.

Second question: As I understand, the _afterTokenTransfer requires an override because two parent classes of MyContract, the ERC721 and ERC721Votes contract both implement _afterTokenTransfer. In order to resolve the confusion of which to call, we have to implement it again in the current contract. But since there is multiple inheritance, what contract does the super keyword refer to??

2

regarding first question: one use-case would be if you need to call the implementation of a virtual method from ERC721 (e.g. ERC721._afterTokenTransfer). If you dont, I dont see any reason why you shouldnt remove the inheritance of ERC721

regarding second question: super._afterTokenTransfer will call the implementation of ERC721Votes. I tested it with the following:

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;

contract A {
    function getValue() virtual public pure returns  (uint){
        return 1;
    }
}

contract B is A {
    function getValue() virtual public override pure returns (uint){
        return 2;
    }
}

contract C is A, B {
    function getValue() public override (A, B) pure returns (uint){
        return super.getValue();
    }

    function getValueOfA() public pure returns (uint) {
        return A.getValue();
    }
}

If you want a deeper understanding of how method resolution works, I suggest reading the docs and linked articles: https://docs.soliditylang.org/en/v0.8.15/contracts.html?highlight=inheritance#multiple-inheritance-and-linearization