HIGH severity: `GovPool::revoteDelegated()` doesn't support multiple tiers of delegation resulting in delegated votes not flowing through to the primary voter. **Description:** When a proposal has `delegatedVotingAllowed == false` such that automatic delegation re-voting will occur in [`GovPoolVote::revoteDelegated()`](https://github.com/dexe-network/DeXe-Protocol/tree/f2fe12eeac0c4c63ac39670912640dc91d94bda5/contracts/libs/gov/gov-pool/GovPoolVote.sol#L10...

Vulnerable code:
describe("audit tiered revoteDelegate", () => {
          // using simple to verify amounts
          let voteAmount     = wei("1000000000000000000");
          let totalVotes1Deg = wei("2000000000000000000");
          let totalVotes2Deg = wei("3000000000000000000");
          let proposal1Id    = 1;

          let FIRST_DELEGATOR;
          let SECOND_DELEGATOR;
          let FINAL_VOTER;

          beforeEach(async () => {
            FIRST_DELEGATOR  = await accounts(10);
            SECOND_DELEGATOR = await accounts(11);
            FINAL_VOTER      = await accounts(12);

            // mint tokens & deposit them to have voting power
            await token.mint(FIRST_DELEGATOR, voteAmount);
            await token.approve(userKeeper.address, voteAmount, { from: FIRST_DELEGATOR });
            await govPool.deposit(FIRST_DELEGATOR, voteAmount, [], { from: FIRST_DELEGATOR });
            await token.mint(SECOND_DELEGATOR, voteAmount);
            await token.approve(userKeeper.address, voteAmount, { from: SECOND_DELEGATOR });
            await govPool.deposit(SECOND_DELEGATOR, voteAmount, [], { from: SECOND_DELEGATOR });
            await token.mint(FINAL_VOTER, voteAmount);
            await token.approve(userKeeper.address, voteAmount, { from: FINAL_VOTER });
            await govPool.deposit(FINAL_VOTER, voteAmount, [], { from: FINAL_VOTER });

            // ensure that delegatedVotingAllowed == false so automatic re-voting
            // will occur for delegation
            let defaultSettings = POOL_PARAMETERS.settingsParams.proposalSettings[0];
            assert.equal(defaultSettings.delegatedVotingAllowed, false);

            // create 1 proposal
            await govPool.createProposal("proposal1", [[token.address, 0, getBytesApprove(SECOND, 1)]], []);

            // verify delegatedVotingAllowed == false
            let proposal1 = await getProposalByIndex(proposal1Id);
            assert.equal(proposal1.core.settings[1], false);
          });

        it("audit testing 3 layer revote delegation", async () => {

          // FINAL_VOTER votes on proposal
          await govPool.vote(proposal1Id, true, voteAmount, [], { from: FINAL_VOTER });

          // verify FINAL_VOTER's voting prior to first delegation
          assert.equal(
            (await govPool.getUserVotes(proposal1Id, FINAL_VOTER, VoteType.PersonalVote)).totalRawVoted,
            voteAmount
          );
          assert.equal(
            (await govPool.getUserVotes(proposal1Id, FINAL_VOTER, VoteType.MicropoolVote)).totalRawVoted,
            "0" // nothing delegated to AUDITOR yet
          );
          assert.equal(
            (await govPool.getTotalVotes(proposal1Id, FINAL_VOTER, VoteType.PersonalVote))[0].toFixed(),
            voteAmount
          );

          // FIRST_DELEGATOR delegates to FINAL_VOTER, this should cancel FINAL_VOTER's original votes
          // and re-vote for FINAL_VOTER which will include the delegated votes
          await govPool.delegate(FINAL_VOTER, voteAmount, [], { from: FIRST_DELEGATOR });

          // verify FINAL_VOTER's voting after first delegation
          assert.equal(
            (await govPool.getUserVotes(proposal1Id, FINAL_VOTER, VoteType.PersonalVote)).totalRawVoted,
            voteAmount // personal votes remain the same
          );
          assert.equal(
            (await govPool.getUserVotes(proposal1Id, FINAL_VOTER, VoteType.MicropoolVote)).totalRawVoted,
            voteAmount // delegated votes now included
          );
          assert.equal(
            (await govPool.getTotalVotes(proposal1Id, FINAL_VOTER, VoteType.PersonalVote))[0].toFixed(),
            totalVotes1Deg // delegated votes now included
          );

          // SECOND_DELEGATOR delegates to FIRST_DELEGATOR. These votes won't carry through into FINAL_VOTER
          await govPool.delegate(FIRST_DELEGATOR, voteAmount, [], { from: SECOND_DELEGATOR });

          // verify FINAL_VOTER's voting after second delegation
          assert.equal(
            (await govPool.getUserVotes(proposal1Id, FINAL_VOTER, VoteType.PersonalVote)).totalRawVoted,
            voteAmount // personal votes remain the same
          );
          assert.equal(
            (await govPool.getUserVotes(proposal1Id, FINAL_VOTER, VoteType.MicropoolVote)).totalRawVoted,
            voteAmount // delegated votes remain the same
          );
          assert.equal(
            (await govPool.getTotalVotes(proposal1Id, FINAL_VOTER, VoteType.PersonalVote))[0].toFixed(),
            totalVotes2Deg // fails here as delegated votes only being counted from the first delegation
          );
        });
      });