Assert that one instance never holds multiple locks on the same file at once.

This could happen if you did 'redo foo foo'.  Which nobody ever did, I
think, but let's make sure we catch it if they do.

One problem with having multiple locks on the same file is then you have to
remember not to *unlock* it until they're all done.  But there are other
problems, such as: why the heck did we think it was a good idea to lock the
same file more than once?  So just prevent it from happening for now,
unless/until we somehow come up with a reason it might be a good idea.

builder.py

@@ -270,12 +270,13 @@ def main(targets, shouldbuildfunc):
         if rv:
             retcode[0] = 1
 
-    for i in range(len(targets)):
-        t = targets[i]
-
     # In the first cycle, we just build as much as we can without worrying
     # about any lock contention.  If someone else has it locked, we move on.
+    seen = {}
     for t in targets:
+        if t in seen:
+            continue
+        seen[t] = 1
         if not jwack.has_token():
             state.commit()
         jwack.get_token(t)
@@ -298,6 +299,8 @@ def main(targets, shouldbuildfunc):
         else:
             BuildJob(t, f, lock, shouldbuildfunc, done).start()
 
+    del lock
+
     # Now we've built all the "easy" ones.  Go back and just wait on the
     # remaining ones one by one.  There's no reason to do it any more
     # efficiently, because if these targets were previously locked, that