This bumps the open zeppelin contracts used in bedrock to the
latest release. This bump is happening because `Ownable` becomes
more flexible, allowing you to overwrite the logic for `onlyOwner`.
This would enable writing a `CrossDomainOwnable` contract like so:

```solidity
// SPDX-License-Identifier: MIT
pragma solidity 0.8.15;

import { AddressAliasHelper } from "../vendor/AddressAliasHelper.sol";
import { Ownable } from "@openzeppelin/contracts/access/Ownable.sol";

abstract contract CrossDomainOwnable is Ownable {
    /**
     * @dev Throws if the sender is not the owner.
     */
    function _checkOwner() internal view {
        address sender = AddressAliasHelper.undoL1ToL2Alias(msg.sender);
        require(owner() == sender, "Ownable: caller is not the owner");
    }
}
```

The main diff to the `Ownable` contract is that is now looks like this:

```solidity
    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        _checkOwner();
        _;
    }

    /**
     * @dev Returns the address of the current owner.
     */
    function owner() public view virtual returns (address) {
        return _owner;
    }

    /**
     * @dev Throws if the sender is not the owner.
     */
    function _checkOwner() internal view virtual {
        require(owner() == _msgSender(), "Ownable: caller is not the owner");
    }
```

The older version of the contracts doesn't have the `virtual`
`_checkOwner` function. This does add some additional gas overhead
as seen in the `.gas-snapshot`.