<think>
Okay, I need to implement the best_harvest function. Let's see. The problem says that the picker can work on days, but once a day is worked, the next day must be off. So, no two consecutive days can both be worked. The goal is to maximize the total yield.

First, the input is a list of non-negative integers representing daily yields. The function should return the maximum possible sum under the constraint. If the input is empty, return 0. Also, need to validate that the input is a list, each element is a non-negative integer.

So, the first thing is to handle the validation. The function should check if the input is a list. If not, raise a ValueError. Then, check each element in the list to ensure they are integers and non-negative. If any of them are invalid, raise ValueError.

Once the input is validated, the next step is to compute the maximum sum. The problem mentions that a greedy approach might not work. For example, the example given is [5, 1, 1, 5], where the optimal is 5 + 5 = 10. If we just pick the first day, then the next day is off, so we can take the last day. But if we had a case where taking a lower value now allows taking higher values later, the greedy approach would fail.

So, this sounds like a dynamic programming problem. Let's think about the recurrence relation. For each day i, the maximum sum up to i is either:

- Take the current day's yield plus the maximum sum up to i-2 (since we can't take i-1)
- Or skip the current day, so the maximum sum up to i-1.

So, the recurrence is dp[i] = max(yields[i] + dp[i-2], dp[i-1])

The base cases would be:

- If there are 0 days, return 0.
- If there is 1 day, take that day's value.
- If there are 2 days, take the maximum of the two.

So, the dynamic programming approach would build up the solution step by step.

Let me think about the example [5, 1, 1, 5]. Let's compute the dp array:

dp[0] = 5
dp[1] = max(1, 5) = 5
dp[2] = max(1 + dp[0], dp[1]) = max(1+5=6, 5) → 6
dp[3] = max(5 + dp[1], dp[2]) → max(5+5=10, 6) → 10. Which matches the example.

So the dynamic programming approach works here.

So, the steps are:

1. Validate the input.
2. Handle edge cases (empty list, single element).
3. Use dynamic programming to compute the maximum sum.

Now, implementing this in Python.

First, the validation. The function is given a list. So, check if the input is a list. If not, raise ValueError. Then, check each element is an integer and non-negative.

Wait, the problem says "an argument that is not a list, a yield that is not an integer, and a negative yield, with an error." So, the function should check that the input is a list, and each element is an integer and non-negative.

So, in code:

def best_harvest(yields: list) -> int:
    if not isinstance(yields, list):
        raise ValueError("Input must be a list")
    for yield_val in yields:
        if not isinstance(yield_val, int) or yield