More than one hat of the same hatId can be assigned to a user
Hats are minted internally using `_mintHat()`.\\n```\\n        /// @notice Internal call to mint a Hat token to a wearer\\n        /// @dev Unsafe if called when `_wearer` has a non-zero balance of `_hatId`\\n        /// @param _wearer The wearer of the Hat and the recipient of the  newly minted token\\n        /// @param _hatId The id of the Hat to mint\\n        function _mintHat(address _wearer, uint256 _hatId) internal {\\n            unchecked {\\n        // should not overflow since `mintHat` enforces max balance of 1\\n            _balanceOf[_wearer][_hatId] = 1;\\n        // increment Hat supply counter\\n        // should not overflow given AllHatsWorn check in `mintHat` ++_hats[_hatId].supply;\\n        }\\n        emit TransferSingle(msg.sender, address(0), _wearer, _hatId, 1);\\n        }\\n```\\n\\nAs documentation states, it is unsafe if _wearer already has the hatId. However, this could easily be the case when called from `mintHat()`.\\n```\\n        function mintHat(uint256 _hatId, address _wearer) public returns (bool) {\\n        Hat memory hat = _hats[_hatId];\\n            if (hat.maxSupply == 0) revert HatDoesNotExist(_hatId);\\n        // only the wearer of a hat's admin Hat can mint it\\n             _checkAdmin(_hatId);\\n            if (hat.supply >= hat.maxSupply) {\\n                 revert AllHatsWorn(_hatId);\\n                     }\\n        if (isWearerOfHat(_wearer, _hatId)) {\\n                revert AlreadyWearingHat(_wearer, _hatId);\\n                      }\\n        _mintHat(_wearer, _hatId);\\n             return true;\\n                  }\\n```\\n\\nThe function validates _wearer doesn't currently wear the hat, but its balance could still be over 0, if the hat is currently toggled off or the wearer is not eligible. The impact is that the hat supply is forever spent, while nobody actually received the hat. This could be used maliciously or occur by accident. When the hat is immutable, the max supply can never be corrected for this leak. It could be used to guarantee no additional, unfriendly hats can be minted to maintain permanent power.
Instead of checking if user currently wears the hat, check if its balance is over 0.
```\\n        /// @notice Internal call to mint a Hat token to a wearer\\n        /// @dev Unsafe if called when `_wearer` has a non-zero balance of `_hatId`\\n        /// @param _wearer The wearer of the Hat and the recipient of the  newly minted token\\n        /// @param _hatId The id of the Hat to mint\\n        function _mintHat(address _wearer, uint256 _hatId) internal {\\n            unchecked {\\n        // should not overflow since `mintHat` enforces max balance of 1\\n            _balanceOf[_wearer][_hatId] = 1;\\n        // increment Hat supply counter\\n        // should not overflow given AllHatsWorn check in `mintHat` ++_hats[_hatId].supply;\\n        }\\n        emit TransferSingle(msg.sender, address(0), _wearer, _hatId, 1);\\n        }\\n```\\n