test(job): scope JobClassRoundTripSpec locals with local.

Second wheels-bot review follow-up from the same batch, on PR #3358.

Every sibling in vendor/wheels/tests/specs/jobs/ declares spec variables with `local.` (e.g.
`local.bootstrapJob = new wheels.Job();` in JobRobustnessSpec). JobClassRoundTripSpec assigned
them unscoped, which runs green but leaks the writes into the spec's `variables` scope.

Purely a convention fix — no behaviour change. Folded in here rather than opened as a third
PR, since it is the same review round on the same merged batch.

lucee7 + sqlite, full core suite: 4756 pass / 0 fail / 0 error, unchanged.

Signed-off-by: Peter Amiri <peter@alurium.com>

Author: bpamiri

vendor/wheels/tests/specs/jobs/JobClassRoundTripSpec.cfc

@@ -17,13 +17,13 @@ component extends="wheels.WheelsTest" {
 		describe("Tests that the persisted jobClass round-trips", () => {
 
 			it("reports a metadata name whose last segment matches the .cfc file name exactly", () => {
-				job = CreateObject("component", "wheels.tests._assets.jobs.ProbeJob")
-				meta = GetMetadata(job)
+				local.job = CreateObject("component", "wheels.tests._assets.jobs.ProbeJob")
+				local.meta = GetMetadata(local.job)
 
-				fileName = ListFirst(ListLast(Replace(meta.path, "\", "/", "all"), "/"), ".")
+				local.fileName = ListFirst(ListLast(Replace(local.meta.path, "\", "/", "all"), "/"), ".")
 
 				// case-sensitive comparison — Compare(), not CompareNoCase()
-				expect(Compare(ListLast(meta.name, "."), fileName)).toBe(0)
+				expect(Compare(ListLast(local.meta.name, "."), local.fileName)).toBe(0)
 			})
 
 			it("never persists a caller's miscased path", () => {
@@ -43,74 +43,74 @@ component extends="wheels.WheelsTest" {
 				//
 				// Asserting only the first would fail on Adobe for a reason that is *safer*
 				// than the one being tested, so assert the property both satisfy.
-				canonical = GetMetadata(CreateObject("component", "wheels.tests._assets.jobs.ProbeJob")).name
-				resolved = {miscasedConstructed = false, name = ""}
+				local.canonical = GetMetadata(CreateObject("component", "wheels.tests._assets.jobs.ProbeJob")).name
+				local.resolved = {miscasedConstructed = false, name = ""}
 
 				try {
-					resolved.name = GetMetadata(CreateObject("component", "wheels.tests._assets.jobs.probejob")).name
-					resolved.miscasedConstructed = true
+					local.resolved.name = GetMetadata(CreateObject("component", "wheels.tests._assets.jobs.probejob")).name
+					local.resolved.miscasedConstructed = true
 				} catch (any e) {
 					// case-sensitive resolver — the stronger guarantee
 				}
 
-				if (resolved.miscasedConstructed) {
-					expect(Compare(resolved.name, canonical)).toBe(0)
+				if (local.resolved.miscasedConstructed) {
+					expect(Compare(local.resolved.name, local.canonical)).toBe(0)
 				} else {
-					expect(resolved.name).toBe("")
+					expect(local.resolved.name).toBe("")
 				}
 			})
 
 			it("re-instantiates from its own persisted metadata name", () => {
 				// the actual enqueue -> drain round trip, without touching the queue table
-				original = CreateObject("component", "wheels.tests._assets.jobs.ProbeJob")
-				persisted = GetMetadata(original).name
+				local.original = CreateObject("component", "wheels.tests._assets.jobs.ProbeJob")
+				local.persisted = GetMetadata(local.original).name
 
 				// Hoisted receiver. A parenthesized `new` in receiver position — `(new X()).m()`
 				// — is rejected by Adobe's parser with `Invalid construct: Either argument or
 				// name is missing`, the same MissingNameException family as cross-engine
 				// invariant 16. Adobe blames the enclosing describe() line and the whole engine
 				// leg reports tests=0. Caught by the compat matrix; Lucee and BoxLang accept it.
-				bridge = new wheels.Job()
-				revived = bridge.$instantiateJobClass(jobClass = persisted)
+				local.bridge = new wheels.Job()
+				local.revived = local.bridge.$instantiateJobClass(jobClass = local.persisted)
 
-				expect(Compare(GetMetadata(revived).name, persisted)).toBe(0)
+				expect(Compare(GetMetadata(local.revived).name, local.persisted)).toBe(0)
 			})
 		})
 
 		describe("Tests that an unresolvable jobClass", () => {
 
 			it("throws Wheels.JobClassNotFound naming the row and the class", () => {
-				thrown = {type: "", message: ""}
+				local.thrown = {type: "", message: ""}
 
-				bridge = new wheels.Job()
+				local.bridge = new wheels.Job()
 
 				try {
-					bridge.$instantiateJobClass(jobClass = "app.jobs.NoSuchJob", jobId = "abc-123")
+					local.bridge.$instantiateJobClass(jobClass = "app.jobs.NoSuchJob", jobId = "abc-123")
 				} catch (any e) {
-					thrown.type = e.type
-					thrown.message = e.message
+					local.thrown.type = e.type
+					local.thrown.message = e.message
 				}
 
 				// the raw engine error is "component not found" for a class that plainly
 				// exists, which points investigators at mappings and deployment
-				expect(thrown.type).toBe("Wheels.JobClassNotFound")
-				expect(thrown.message).toInclude("app.jobs.NoSuchJob")
-				expect(thrown.message).toInclude("abc-123")
+				expect(local.thrown.type).toBe("Wheels.JobClassNotFound")
+				expect(local.thrown.message).toInclude("app.jobs.NoSuchJob")
+				expect(local.thrown.message).toInclude("abc-123")
 			})
 
 			it("throws Wheels.InvalidJobClass when the path resolves to something that is not a job", () => {
-				thrown = {type: ""}
+				local.thrown = {type: ""}
 
-				bridge = new wheels.Job()
+				local.bridge = new wheels.Job()
 
 				try {
 					// a real component with no perform()
-					bridge.$instantiateJobClass(jobClass = "wheels.tests._assets.models.Post")
+					local.bridge.$instantiateJobClass(jobClass = "wheels.tests._assets.models.Post")
 				} catch (any e) {
-					thrown.type = e.type
+					local.thrown.type = e.type
 				}
 
-				expect(thrown.type).toBe("Wheels.InvalidJobClass")
+				expect(local.thrown.type).toBe("Wheels.InvalidJobClass")
 			})
 		})
 	}