In specific Edge case calculation for `Prizevault:maxdeposit` and `Prizevault:maxredeem` is inaccurate and could potentially cause a denial-of-service (DOS) attack
Audit: 2024-03-pooltogether-findings
Severity: MEDIUM

# Lines of code

https://github.com/code-423n4/2024-03-pooltogether/blob/480d58b9e8611c13587f28811864aea138a0021a/pt-v5-vault/src/PrizeVault.sol#L404
https://github.com/code-423n4/2024-03-pooltogether/blob/480d58b9e8611c13587f28811864aea138a0021a/pt-v5-vault/src/PrizeVault.sol#L415


# Vulnerability details

## Impact
According to the EIP426 it states that maxwithdrwal and maxredeem "MUST factor in both global and user-specific limits". However this wasnt properly reflected in the Prizevault implementation. Lets say we have a scenario where an underlying yeildvault places a temporary limits either global or user sepecific to the prizevault. We will have a situation where even though `totalAssets >= totalDebt`, maximum redeemable yeild vault shares is less than total yeild vault shares owned by the prizevault. But this limitation will not reflect on holder of the Prizevault shares( a limitation they would have experienced depositing directly into the yield vault if its a global limitation) when they call the `Prizevault:maxredeem` or `Prizevault:maxdeposit`. Lets do a walkthrough of the code base to illustrate this.
```

function maxRedeem(address _owner) public view returns (uint256) {
        uint256 _maxWithdraw = _maxYieldVaultWithdraw() + _asset.balanceOf(address(this));
        uint256 _ownerShares = balanceOf(_owner);

        // The owner will never receive more than 1 asset per share, so there is no need to convert max
        // withdraw to shares unless the owner has more shares than the max withdraw and is redeeming
        // at a loss (when 1 share is worth less than 1 asset).
        if (_ownerShares > _maxWithdraw) {
            uint256 _totalAssets = totalAssets();
            uint256 totalDebt_ = totalDebt();
            if (_totalAssets >= totalDebt_) {
                return _maxWithdraw;
            } else {
                // Convert to shares while rounding up. Since 1 asset is guaranteed to be worth more than
                // 1 share and any upwards rounding will not exceed 1 share, we can be sure that when the
                // shares are converted back to assets (rounding down) the resulting asset value won't
                // exceed `_maxWithdraw`.
                uint256 _maxScaledRedeem = _maxWithdraw.mulDiv(totalDebt_, _totalAssets, Math.Rounding.Up);
                return _maxScaledRedeem >= _ownerShares ? _ownerShares : _maxScaledRedeem;
            }
        } else {
            return _ownerShares;
        }
    }


```

```
 uint256 _maxWithdraw = _maxYieldVaultWithdraw() + _asset.balanceOf(address(this));

function _maxYieldVaultWithdraw() internal view returns (uint256) {
        return yieldVault.convertToAssets(yieldVault.maxRedeem(address(this)));
```
 So  `_maxWithdraw` = max redeemable yield vault share which is limited in this edgecase.

`uint256 _ownerShares = balanceOf(_owner);` this will reflect the entire prizevault shares of the _owner not accounting for limitations above.

Hypothetically lets a