Update `modify()` logic within `LedgerCSVDataFrameEntity` class

[AlexTheWizardL]

The logic implemented for the modify() method within LedgerCSVDataFrameEntity class in the loop does not work for making multiple modifications at once within the same file.

• We loop over modifications (or ids), in case of multiple modifications to the same file, code in the loop is executed multiple times for the same file.
• The entry to be replaced is dropped, a new entry added to the end of the file.
• Cache is not updated in the iteration, meaning we get the unmodified entries in the next iteration and ignore the modification just made.
• The logic would not work even if the cache was updated, because appending the modified entry at the end potentially modifies all ids within the file
• Dropping the entry to be deleted from its current position in the file and adding the modified entry at the end of the file is counter our principle to generate minimal git diffs.

This means we have two problems:

• The code does not do what we expect in case of multiple modifications within the same ledger file.
• The test suite failed to detect this problem.

Please address both points in the following sequence:

1. write a test that catches this problem and demonstrate that the test fails as expected.
2. Then fix the code and demonstrate that the test suite now passes.

[AlexTheWizardL]

I've tested the logic for the LedgerCSVDataFrameEntity modify() method and it is working. Here is why:

• The cache was cleared since invalidation is invoked by the _store method.
• Order is overwritten by pd.concat() - that is true, but then our write_ledger_file() method within the TextLedger sorts rows by id numeric part. Done along this line: df = df.iloc[self.ledger._id_from_path(df["id"]).argsort(kind="mergesort")] I removed that line for sorting and now the test catches the problem. It is shown in this failed test action

What it means:

• Our test_ledger_mutators_does_not_change_order() test is not broken.
• Logic is still not performant and needs to be overwritten anyway.