Remove JVM dependency regarding synchronization

Remove @synchronized annotation and CopyOnWriteArraySet usage.
They were used just to prevent users from common errors.
StateMachine cannot be used from multiple thread without external synchronisation as mentioned in docs same as before.

Removing JVM dependency is a next step to Kotlin multiplatform support.

Author: nsk90

kstatemachine/src/main/kotlin/ru/nsk/kstatemachine/BaseStateImpl.kt

@@ -2,12 +2,11 @@ package ru.nsk.kstatemachine
 
 import ru.nsk.kstatemachine.TreeAlgorithms.findPathFromTargetToLca
 import ru.nsk.kstatemachine.visitors.GetActiveStatesVisitor
-import java.util.concurrent.CopyOnWriteArraySet
 
 open class BaseStateImpl(override val name: String?, override val childMode: ChildMode) : InternalState() {
 
     private class Data {
-        val listeners = CopyOnWriteArraySet<IState.Listener>()
+        val listeners = mutableSetOf<IState.Listener>()
         val states = mutableSetOf<InternalState>()
         var initialState: InternalState? = null
 

kstatemachine/src/main/kotlin/ru/nsk/kstatemachine/DefaultTransition.kt

@@ -1,13 +1,11 @@
 package ru.nsk.kstatemachine
 
-import java.util.concurrent.CopyOnWriteArraySet
-
 open class DefaultTransition<E : Event>(
     override val name: String?,
     override val eventMatcher: EventMatcher<E>,
     sourceState: IState
 ) : InternalTransition<E> {
-    private val _listeners = CopyOnWriteArraySet<Transition.Listener>()
+    private val _listeners = mutableSetOf<Transition.Listener>()
     override val listeners: Collection<Transition.Listener> get() = _listeners
     override val sourceState = sourceState as InternalState
 

kstatemachine/src/main/kotlin/ru/nsk/kstatemachine/StateMachine.kt

@@ -9,6 +9,7 @@ interface StateMachine : State {
     var logger: Logger
     var ignoredEventHandler: IgnoredEventHandler
     var pendingEventHandler: PendingEventHandler
+
     /**
      * If machine catches exception from client code (listeners callbacks) it stores it until event processing
      * completes, and passes it to this handler. That keeps machine in well-defined predictable state and allows

kstatemachine/src/main/kotlin/ru/nsk/kstatemachine/StateMachineImpl.kt

@@ -48,13 +48,11 @@ internal class StateMachineImpl(name: String?, childMode: ChildMode, override va
         override fun log(message: String) {}
     }
 
-    @Synchronized
     override fun <L : StateMachine.Listener> addListener(listener: L): L {
         require(_machineListeners.add(listener)) { "$listener is already added" }
         return listener
     }
 
-    @Synchronized
     override fun removeListener(listener: StateMachine.Listener) {
         _machineListeners.remove(listener)
     }
@@ -104,7 +102,6 @@ internal class StateMachineImpl(name: String?, childMode: ChildMode, override va
         }
     }
 
-    @Synchronized
     override fun processEvent(event: Event, argument: Any?) {
         check(!isDestroyed) { "$this is already destroyed" }
         check(isRunning) { "$this is not started, call start() first" }