Hi Ed,
Internally, NUnit uses sequentially generated IDs to represent the tests it discovers.
NCrunch can't use these IDs between different versions of your assembly/project, because it's natural that the list of tests in the project could be changed while you work. You add them, remove them, etc. This would cause the IDs to shift between tests making it impossible to identify them between verions of the project. For this reason, NCrunch generates its own identifier using data related to the test, such as its fixture, method, parameters, and the results of the .SetName() method.
If you're no longer seeing a report about duplicate test names for the tests involved, then .SetName() is working correctly and NCrunch is not having difficulty telling the tests apart.
However, because NUnit can only be instructed to run tests using its own internal ID, NCrunch still uses these IDs within the scope of a single codebase version to instruct NUnit on which tests to execute. Although the IDs are dumped between versions of a project (where they no longer apply), they are re-used between processes that are created for parallel execution. NCrunch assumes that invoking an NUnit test discovery action over the same test assembly will always return the same result with the same set of sequential IDs, with the same tests returned to NUnit in the same order.
There are theoretical situations where this won't hold true. For example, if you are generating your tests out of a database, the state of the database might change without NCrunch being aware of it. Because the test project/assembly hasn't changed, NCrunch assumes everything is fine even though the state used to generate the tests may have changed. This causes inconsistencies in test identification, because the physical list of tests to execute has shifted out from under the engine.
The problems you're describing match a scenario like this. Note that because the IDs are sequential, these inconsistencies can affect the entire test assembly when they appear. You may have just one test declared early in the test suite that 'disappears' after it is discovered, and then every other test in the suite will have execution problems and may report inconsistent results.