Implement a calculator that can compute arithmetic expressions involving addition, subtraction, multiplication, and division operations. The expressions will consist of integers and operators, separated by spaces. The calculator should adhere to the following rules:
- The operators must be evaluated according to the correct precedence of operations (i.e., multiplication and division before addition and subtraction).
- The calculator should support parentheses to override the precedence of operations.
- The calculator should handle negative numbers and floating-point numbers as well.
- The calculator should handle invalid expressions and provide appropriate error messages.

Example expressions:
1. "3 + 5 * 2"
2. "4 - (7 / 3 + 2)"
3. "10 * (3 - 2.5)"

Note: Implementing a full-fledged mathematical expression parser is beyond the scope of this question. The focus should be on correctly implementing the evaluation of arithmetic expressions with the specified rules and handling different types of numbers.
To implement the calculator, we can use the following steps:

1. Create a function named `calculate` that takes in an arithmetic expression as a string.
2. Initialize a stack to store the operators and operands.
3. Iterate through the expression from left to right.
4. If the current character is a space, continue to the next character.
5. If the current character is an open parenthesis '(', push it onto the stack.
6. If the current character is a digit or a decimal point '.', extract the entire number and push it onto the stack.
7. If the current character is a closing parenthesis ')', repeatedly pop operators from the stack and evaluate them until an open parenthesis is encountered. Push the result onto the stack.
8. If the current character is an operator (+, -, *, /), repeatedly pop operators from the stack and evaluate them if they have higher precedence or equal precedence with the current operator. Push the result onto the stack.
9. After iterating through the expression, repeatedly pop operators from the stack and evaluate them until the stack is empty.
10. The final result will be the only element left on the stack. Return it as the result of the calculation.

Here's the implementation in Python:

```python
def calculate(expression):
    stack = []
    operators = {'+': 1, '-': 1, '*': 2, '/': 2}
    i = 0

    while i < len(expression):
        if expression[i] == ' ':
            i += 1
            continue
        elif expression[i] == '(':
            stack.append(expression[i])
        elif expression[i].isdigit() or expression[i] == '.':
            num_str = ''
            while i < len(expression) and (expression[i].isdigit() or expression[i] == '.'):
                num_str += expression[i]
                i += 1
            stack.append(float(num_str))
            continue
        elif expression[i] == ')':
            while stack and stack[-1] != '(':
                result = perform_operation(stack.pop(), stack.pop(), stack.pop())
                stack.append(result)
            stack.pop()  # Remove the open parenthesis
        elif expression[i] in operators:
            while stack and stack[-1] != '(' and operators[expression[i]] <= operators.get(stack[-1], 0):
                result = perform_operation(stack.pop(), stack.pop(), stack.pop())
                stack.append(result)
            stack.append(expression[i])
        i += 1

    while stack and len(stack) > 1:
        result = perform_operation(stack.pop(), stack.pop(), stack.pop())
        stack.append(result)

    return stack[0]


def perform_operation(operator, b, a):
    if operator == '+':
        return a + b
    elif operator == '-':
        return a - b
    elif operator == '*':
        return a * b
    elif operator == '/':
        if b == 0:
            raise ValueError("Division by zero is not allowed")
        return a / b
```

You can test the calculator with the example expressions you provided:

```python
print(calculate("3 + 5 * 2"))  # Output: 13.0
print(calculate("4 - (7 / 3 + 2)"))  # Output: 2.6666666666666665
print(calculate("10 * (3 - 2.5)"))  # Output: 5.0
```